<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE DeriveDataTypeable #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE FlexibleContexts #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# LANGUAGE PolymorphicComponents #-}</span><span>
</span><span id="line-5"></span><span class="hs-pragma">{-# LANGUAGE Safe #-}</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- Module      :  Text.Parsec.Token</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Copyright   :  (c) Daan Leijen 1999-2001, (c) Paolo Martini 2007</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- License     :  BSD-style (see the LICENSE file)</span><span>
</span><span id="line-12"></span><span class="hs-comment">--</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- Maintainer  :  derek.a.elkins@gmail.com</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- Stability   :  provisional</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- Portability :  non-portable (uses local universal quantification: PolymorphicComponents)</span><span>
</span><span id="line-16"></span><span class="hs-comment">--</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- A helper module to parse lexical elements (tokens). See 'makeTokenParser'</span><span>
</span><span id="line-18"></span><span class="hs-comment">-- for a description of how to use it.</span><span>
</span><span id="line-19"></span><span class="hs-comment">--</span><span>
</span><span id="line-20"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-21"></span><span>
</span><span id="line-22"></span><span class="hs-pragma">{-# OPTIONS_GHC -fno-warn-name-shadowing #-}</span><span>
</span><span id="line-23"></span><span>
</span><span id="line-24"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Text.Parsec.Token</span><span>
</span><span id="line-25"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#LanguageDef"><span class="hs-identifier">LanguageDef</span></a></span><span>
</span><span id="line-26"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenLanguageDef"><span class="hs-identifier">GenLanguageDef</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-27"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#TokenParser"><span class="hs-identifier">TokenParser</span></a></span><span>
</span><span id="line-28"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenTokenParser"><span class="hs-identifier">GenTokenParser</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-29"></span><span>    </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#makeTokenParser"><span class="hs-identifier">makeTokenParser</span></a></span><span>
</span><span id="line-30"></span><span>    </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-31"></span><span>
</span><span id="line-32"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#"><span class="hs-identifier">Data.Char</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Unicode.html#isAlpha"><span class="hs-identifier">isAlpha</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier">toLower</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Unicode.html#toUpper"><span class="hs-identifier">toUpper</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Unicode.html#isSpace"><span class="hs-identifier">isSpace</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#digitToInt"><span class="hs-identifier">digitToInt</span></a></span><span> </span><span class="hs-special">)</span><span class="hs-cpp">
#if MIN_VERSION_base(4,7,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.html#"><span class="hs-identifier">Data.Typeable</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Typeable"><span class="hs-identifier">Typeable</span></a></span><span> </span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.OldList.html#nub"><span class="hs-identifier">nub</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.OldList.html#sort"><span class="hs-identifier">sort</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-37"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../mtl/src/Control.Monad.Identity.html#"><span class="hs-identifier">Control.Monad.Identity</span></a></span><span>
</span><span id="line-38"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html"><span class="hs-identifier">Text.Parsec.Prim</span></a></span><span>
</span><span id="line-39"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Parsec.Char.html"><span class="hs-identifier">Text.Parsec.Char</span></a></span><span>
</span><span id="line-40"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.Parsec.Combinator.html"><span class="hs-identifier">Text.Parsec.Combinator</span></a></span><span>
</span><span id="line-41"></span><span>
</span><span id="line-42"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-43"></span><span class="hs-comment">-- Language Definition</span><span>
</span><span id="line-44"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span class="hs-keyword">type</span><span> </span><span id="LanguageDef"><span class="annot"><a href="Text.Parsec.Token.html#LanguageDef"><span class="hs-identifier hs-var">LanguageDef</span></a></span></span><span> </span><span id="local-6989586621679061887"><span class="annot"><a href="#local-6989586621679061887"><span class="hs-identifier hs-type">st</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenLanguageDef"><span class="hs-identifier hs-type">GenLanguageDef</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679061887"><span class="hs-identifier hs-type">st</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span>
</span><span id="line-47"></span><span>
</span><span id="line-48"></span><span class="hs-comment">-- | The @GenLanguageDef@ type is a record that contains all parameterizable</span><span>
</span><span id="line-49"></span><span class="hs-comment">-- features of the &quot;Text.Parsec.Token&quot; module. The module &quot;Text.Parsec.Language&quot;</span><span>
</span><span id="line-50"></span><span class="hs-comment">-- contains some default definitions.</span><span>
</span><span id="line-51"></span><span>
</span><span id="line-52"></span><span class="hs-keyword">data</span><span> </span><span id="GenLanguageDef"><span class="annot"><a href="Text.Parsec.Token.html#GenLanguageDef"><span class="hs-identifier hs-var">GenLanguageDef</span></a></span></span><span> </span><span id="local-6989586621679062294"><span class="annot"><a href="#local-6989586621679062294"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span id="local-6989586621679062293"><span class="annot"><a href="#local-6989586621679062293"><span class="hs-identifier hs-type">u</span></a></span></span><span> </span><span id="local-6989586621679062292"><span class="annot"><a href="#local-6989586621679062292"><span class="hs-identifier hs-type">m</span></a></span></span><span>
</span><span id="line-53"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span id="LanguageDef"><span class="annot"><a href="Text.Parsec.Token.html#LanguageDef"><span class="hs-identifier hs-var">LanguageDef</span></a></span></span><span> </span><span class="hs-special">{</span><span>
</span><span id="line-54"></span><span>
</span><span id="line-55"></span><span>    </span><span class="hs-comment">-- | Describes the start of a block comment. Use the empty string if the</span><span>
</span><span id="line-56"></span><span>    </span><span class="hs-comment">-- language doesn't support block comments. For example \&quot;\/*\&quot;.</span><span>
</span><span id="line-57"></span><span>
</span><span id="line-58"></span><span>    </span><span id="commentStart"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentStart"><span class="hs-identifier hs-var hs-var">commentStart</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-59"></span><span>
</span><span id="line-60"></span><span>    </span><span class="hs-comment">-- | Describes the end of a block comment. Use the empty string if the</span><span>
</span><span id="line-61"></span><span>    </span><span class="hs-comment">-- language doesn't support block comments. For example \&quot;*\/\&quot;.</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span>    </span><span id="commentEnd"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentEnd"><span class="hs-identifier hs-var hs-var">commentEnd</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-64"></span><span>
</span><span id="line-65"></span><span>    </span><span class="hs-comment">-- | Describes the start of a line comment. Use the empty string if the</span><span>
</span><span id="line-66"></span><span>    </span><span class="hs-comment">-- language doesn't support line comments. For example \&quot;\/\/\&quot;.</span><span>
</span><span id="line-67"></span><span>
</span><span id="line-68"></span><span>    </span><span id="commentLine"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentLine"><span class="hs-identifier hs-var hs-var">commentLine</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-69"></span><span>
</span><span id="line-70"></span><span>    </span><span class="hs-comment">-- | Set to 'True' if the language supports nested block comments.</span><span>
</span><span id="line-71"></span><span>
</span><span id="line-72"></span><span>    </span><span id="nestedComments"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#nestedComments"><span class="hs-identifier hs-var hs-var">nestedComments</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">,</span><span>
</span><span id="line-73"></span><span>
</span><span id="line-74"></span><span>    </span><span class="hs-comment">-- | This parser should accept any start characters of identifiers. For</span><span>
</span><span id="line-75"></span><span>    </span><span class="hs-comment">-- example @letter \&lt;|&gt; char \'_\'@.</span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span>    </span><span id="identStart"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#identStart"><span class="hs-identifier hs-var hs-var">identStart</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062294"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062293"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062292"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">,</span><span>
</span><span id="line-78"></span><span>
</span><span id="line-79"></span><span>    </span><span class="hs-comment">-- | This parser should accept any legal tail characters of identifiers.</span><span>
</span><span id="line-80"></span><span>    </span><span class="hs-comment">-- For example @alphaNum \&lt;|&gt; char \'_\'@.</span><span>
</span><span id="line-81"></span><span>
</span><span id="line-82"></span><span>    </span><span id="identLetter"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#identLetter"><span class="hs-identifier hs-var hs-var">identLetter</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062294"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062293"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062292"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">,</span><span>
</span><span id="line-83"></span><span>
</span><span id="line-84"></span><span>    </span><span class="hs-comment">-- | This parser should accept any start characters of operators. For</span><span>
</span><span id="line-85"></span><span>    </span><span class="hs-comment">-- example @oneOf \&quot;:!#$%&amp;*+.\/\&lt;=&gt;?\@\\\\^|-~\&quot;@</span><span>
</span><span id="line-86"></span><span>
</span><span id="line-87"></span><span>    </span><span id="opStart"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#opStart"><span class="hs-identifier hs-var hs-var">opStart</span></a></span></span><span>        </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062294"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062293"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062292"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">,</span><span>
</span><span id="line-88"></span><span>
</span><span id="line-89"></span><span>    </span><span class="hs-comment">-- | This parser should accept any legal tail characters of operators.</span><span>
</span><span id="line-90"></span><span>    </span><span class="hs-comment">-- Note that this parser should even be defined if the language doesn't</span><span>
</span><span id="line-91"></span><span>    </span><span class="hs-comment">-- support user-defined operators, or otherwise the 'reservedOp'</span><span>
</span><span id="line-92"></span><span>    </span><span class="hs-comment">-- parser won't work correctly.</span><span>
</span><span id="line-93"></span><span>
</span><span id="line-94"></span><span>    </span><span id="opLetter"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#opLetter"><span class="hs-identifier hs-var hs-var">opLetter</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062294"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062293"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062292"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">,</span><span>
</span><span id="line-95"></span><span>
</span><span id="line-96"></span><span>    </span><span class="hs-comment">-- | The list of reserved identifiers.</span><span>
</span><span id="line-97"></span><span>
</span><span id="line-98"></span><span>    </span><span id="reservedNames"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; [String]
</span><a href="Text.Parsec.Token.html#reservedNames"><span class="hs-identifier hs-var hs-var">reservedNames</span></a></span></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span>
</span><span id="line-99"></span><span>
</span><span id="line-100"></span><span>    </span><span class="hs-comment">-- | The list of reserved operators.</span><span>
</span><span id="line-101"></span><span>
</span><span id="line-102"></span><span>    </span><span id="reservedOpNames"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; [String]
</span><a href="Text.Parsec.Token.html#reservedOpNames"><span class="hs-identifier hs-var hs-var">reservedOpNames</span></a></span></span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span>
</span><span id="line-103"></span><span>
</span><span id="line-104"></span><span>    </span><span class="hs-comment">-- | Set to 'True' if the language is case sensitive.</span><span>
</span><span id="line-105"></span><span>
</span><span id="line-106"></span><span>    </span><span id="caseSensitive"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#caseSensitive"><span class="hs-identifier hs-var hs-var">caseSensitive</span></a></span></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span>
</span><span id="line-107"></span><span>
</span><span id="line-108"></span><span>    </span><span class="hs-special">}</span><span class="hs-cpp">
#if MIN_VERSION_base(4,7,0)
</span><span>    </span><span class="hs-keyword">deriving</span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Typeable"><span class="hs-identifier hs-type">Typeable</span></a></span><span> </span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-113"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-114"></span><span class="hs-comment">-- A first class module: TokenParser</span><span>
</span><span id="line-115"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span class="hs-keyword">type</span><span> </span><span id="TokenParser"><span class="annot"><a href="Text.Parsec.Token.html#TokenParser"><span class="hs-identifier hs-var">TokenParser</span></a></span></span><span> </span><span id="local-6989586621679061873"><span class="annot"><a href="#local-6989586621679061873"><span class="hs-identifier hs-type">st</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenTokenParser"><span class="hs-identifier hs-type">GenTokenParser</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679061873"><span class="hs-identifier hs-type">st</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Functor.Identity.html#Identity"><span class="hs-identifier hs-type">Identity</span></a></span><span>
</span><span id="line-118"></span><span>
</span><span id="line-119"></span><span class="hs-comment">-- | The type of the record that holds lexical parsers that work on</span><span>
</span><span id="line-120"></span><span class="hs-comment">-- @s@ streams with state @u@ over a monad @m@.</span><span>
</span><span id="line-121"></span><span>
</span><span id="line-122"></span><span class="hs-keyword">data</span><span> </span><span id="GenTokenParser"><span class="annot"><a href="Text.Parsec.Token.html#GenTokenParser"><span class="hs-identifier hs-var">GenTokenParser</span></a></span></span><span> </span><span id="local-6989586621679062256"><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span></span><span> </span><span id="local-6989586621679062255"><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span></span><span> </span><span id="local-6989586621679062254"><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span></span><span>
</span><span id="line-123"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span id="TokenParser"><span class="annot"><a href="Text.Parsec.Token.html#TokenParser"><span class="hs-identifier hs-var">TokenParser</span></a></span></span><span> </span><span class="hs-special">{</span><span>
</span><span id="line-124"></span><span>
</span><span id="line-125"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a legal identifier. Returns the identifier</span><span>
</span><span id="line-126"></span><span>        </span><span class="hs-comment">-- string. This parser will fail on identifiers that are reserved</span><span>
</span><span id="line-127"></span><span>        </span><span class="hs-comment">-- words. Legal identifier (start) characters and reserved words are</span><span>
</span><span id="line-128"></span><span>        </span><span class="hs-comment">-- defined in the 'LanguageDef' that is passed to</span><span>
</span><span id="line-129"></span><span>        </span><span class="hs-comment">-- 'makeTokenParser'. An @identifier@ is treated as</span><span>
</span><span id="line-130"></span><span>        </span><span class="hs-comment">-- a single token using 'try'.</span><span>
</span><span id="line-131"></span><span>
</span><span id="line-132"></span><span>        </span><span id="identifier"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#identifier"><span class="hs-identifier hs-var hs-var">identifier</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-133"></span><span>
</span><span id="line-134"></span><span>        </span><span class="hs-comment">-- | The lexeme parser @reserved name@ parses @symbol</span><span>
</span><span id="line-135"></span><span>        </span><span class="hs-comment">-- name@, but it also checks that the @name@ is not a prefix of a</span><span>
</span><span id="line-136"></span><span>        </span><span class="hs-comment">-- valid identifier. A @reserved@ word is treated as a single token</span><span>
</span><span id="line-137"></span><span>        </span><span class="hs-comment">-- using 'try'.</span><span>
</span><span id="line-138"></span><span>
</span><span id="line-139"></span><span>        </span><span id="reserved"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; String -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#reserved"><span class="hs-identifier hs-var hs-var">reserved</span></a></span></span><span>         </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-140"></span><span>
</span><span id="line-141"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a legal operator. Returns the name of the</span><span>
</span><span id="line-142"></span><span>        </span><span class="hs-comment">-- operator. This parser will fail on any operators that are reserved</span><span>
</span><span id="line-143"></span><span>        </span><span class="hs-comment">-- operators. Legal operator (start) characters and reserved operators</span><span>
</span><span id="line-144"></span><span>        </span><span class="hs-comment">-- are defined in the 'LanguageDef' that is passed to</span><span>
</span><span id="line-145"></span><span>        </span><span class="hs-comment">-- 'makeTokenParser'. An @operator@ is treated as a</span><span>
</span><span id="line-146"></span><span>        </span><span class="hs-comment">-- single token using 'try'.</span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span>        </span><span id="operator"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#operator"><span class="hs-identifier hs-var hs-var">operator</span></a></span></span><span>         </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-149"></span><span>
</span><span id="line-150"></span><span>        </span><span class="hs-comment">-- |The lexeme parser @reservedOp name@ parses @symbol</span><span>
</span><span id="line-151"></span><span>        </span><span class="hs-comment">-- name@, but it also checks that the @name@ is not a prefix of a</span><span>
</span><span id="line-152"></span><span>        </span><span class="hs-comment">-- valid operator. A @reservedOp@ is treated as a single token using</span><span>
</span><span id="line-153"></span><span>        </span><span class="hs-comment">-- 'try'.</span><span>
</span><span id="line-154"></span><span>
</span><span id="line-155"></span><span>        </span><span id="reservedOp"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; String -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#reservedOp"><span class="hs-identifier hs-var hs-var">reservedOp</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-156"></span><span>
</span><span id="line-157"></span><span>
</span><span id="line-158"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a single literal character. Returns the</span><span>
</span><span id="line-159"></span><span>        </span><span class="hs-comment">-- literal character value. This parsers deals correctly with escape</span><span>
</span><span id="line-160"></span><span>        </span><span class="hs-comment">-- sequences. The literal character is parsed according to the grammar</span><span>
</span><span id="line-161"></span><span>        </span><span class="hs-comment">-- rules defined in the Haskell report (which matches most programming</span><span>
</span><span id="line-162"></span><span>        </span><span class="hs-comment">-- languages quite closely).</span><span>
</span><span id="line-163"></span><span>
</span><span id="line-164"></span><span>        </span><span id="charLiteral"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#charLiteral"><span class="hs-identifier hs-var hs-var">charLiteral</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">,</span><span>
</span><span id="line-165"></span><span>
</span><span id="line-166"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a literal string. Returns the literal</span><span>
</span><span id="line-167"></span><span>        </span><span class="hs-comment">-- string value. This parsers deals correctly with escape sequences and</span><span>
</span><span id="line-168"></span><span>        </span><span class="hs-comment">-- gaps. The literal string is parsed according to the grammar rules</span><span>
</span><span id="line-169"></span><span>        </span><span class="hs-comment">-- defined in the Haskell report (which matches most programming</span><span>
</span><span id="line-170"></span><span>        </span><span class="hs-comment">-- languages quite closely).</span><span>
</span><span id="line-171"></span><span>
</span><span id="line-172"></span><span>        </span><span id="stringLiteral"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#stringLiteral"><span class="hs-identifier hs-var hs-var">stringLiteral</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-173"></span><span>
</span><span id="line-174"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a natural number (a positive whole</span><span>
</span><span id="line-175"></span><span>        </span><span class="hs-comment">-- number). Returns the value of the number. The number can be</span><span>
</span><span id="line-176"></span><span>        </span><span class="hs-comment">-- specified in 'decimal', 'hexadecimal' or</span><span>
</span><span id="line-177"></span><span>        </span><span class="hs-comment">-- 'octal'. The number is parsed according to the grammar</span><span>
</span><span id="line-178"></span><span>        </span><span class="hs-comment">-- rules in the Haskell report.</span><span>
</span><span id="line-179"></span><span>
</span><span id="line-180"></span><span>        </span><span id="natural"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#natural"><span class="hs-identifier hs-var hs-var">natural</span></a></span></span><span>          </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span>
</span><span id="line-181"></span><span>
</span><span id="line-182"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses an integer (a whole number). This parser</span><span>
</span><span id="line-183"></span><span>        </span><span class="hs-comment">-- is like 'natural' except that it can be prefixed with</span><span>
</span><span id="line-184"></span><span>        </span><span class="hs-comment">-- sign (i.e. \'-\' or \'+\'). Returns the value of the number. The</span><span>
</span><span id="line-185"></span><span>        </span><span class="hs-comment">-- number can be specified in 'decimal', 'hexadecimal'</span><span>
</span><span id="line-186"></span><span>        </span><span class="hs-comment">-- or 'octal'. The number is parsed according</span><span>
</span><span id="line-187"></span><span>        </span><span class="hs-comment">-- to the grammar rules in the Haskell report.</span><span>
</span><span id="line-188"></span><span>
</span><span id="line-189"></span><span>        </span><span id="integer"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#integer"><span class="hs-identifier hs-var hs-var">integer</span></a></span></span><span>          </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span>
</span><span id="line-190"></span><span>
</span><span id="line-191"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses a floating point value. Returns the value</span><span>
</span><span id="line-192"></span><span>        </span><span class="hs-comment">-- of the number. The number is parsed according to the grammar rules</span><span>
</span><span id="line-193"></span><span>        </span><span class="hs-comment">-- defined in the Haskell report.</span><span>
</span><span id="line-194"></span><span>
</span><span id="line-195"></span><span>        </span><span id="float"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Double
</span><a href="Text.Parsec.Token.html#float"><span class="hs-identifier hs-var hs-var">float</span></a></span></span><span>            </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span class="hs-special">,</span><span>
</span><span id="line-196"></span><span>
</span><span id="line-197"></span><span>        </span><span class="hs-comment">-- | This lexeme parser parses either 'natural' or a 'float'.</span><span>
</span><span id="line-198"></span><span>        </span><span class="hs-comment">-- Returns the value of the number. This parsers deals with</span><span>
</span><span id="line-199"></span><span>        </span><span class="hs-comment">-- any overlap in the grammar rules for naturals and floats. The number</span><span>
</span><span id="line-200"></span><span>        </span><span class="hs-comment">-- is parsed according to the grammar rules defined in the Haskell report.</span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>        </span><span id="naturalOrFloat"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m (Either Integer Double)
</span><a href="Text.Parsec.Token.html#naturalOrFloat"><span class="hs-identifier hs-var hs-var">naturalOrFloat</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-203"></span><span>
</span><span id="line-204"></span><span>        </span><span class="hs-comment">-- | Parses a non-negative whole number in the decimal system. Returns the</span><span>
</span><span id="line-205"></span><span>        </span><span class="hs-comment">-- value of the number.</span><span>
</span><span id="line-206"></span><span>
</span><span id="line-207"></span><span>        </span><span id="decimal"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#decimal"><span class="hs-identifier hs-var hs-var">decimal</span></a></span></span><span>          </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span>
</span><span id="line-208"></span><span>
</span><span id="line-209"></span><span>        </span><span class="hs-comment">-- | Parses a non-negative whole number in the hexadecimal system. The</span><span>
</span><span id="line-210"></span><span>        </span><span class="hs-comment">-- number should be prefixed with \&quot;x\&quot; or \&quot;X\&quot;. Returns the value of the</span><span>
</span><span id="line-211"></span><span>        </span><span class="hs-comment">-- number.</span><span>
</span><span id="line-212"></span><span>
</span><span id="line-213"></span><span>        </span><span id="hexadecimal"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#hexadecimal"><span class="hs-identifier hs-var hs-var">hexadecimal</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span>
</span><span id="line-214"></span><span>
</span><span id="line-215"></span><span>        </span><span class="hs-comment">-- | Parses a non-negative whole number in the octal system. The number</span><span>
</span><span id="line-216"></span><span>        </span><span class="hs-comment">-- should be prefixed with \&quot;o\&quot; or \&quot;O\&quot;. Returns the value of the</span><span>
</span><span id="line-217"></span><span>        </span><span class="hs-comment">-- number.</span><span>
</span><span id="line-218"></span><span>
</span><span id="line-219"></span><span>        </span><span id="octal"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#octal"><span class="hs-identifier hs-var hs-var">octal</span></a></span></span><span>            </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">,</span><span>
</span><span id="line-220"></span><span>
</span><span id="line-221"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @symbol s@ parses 'string' @s@ and skips</span><span>
</span><span id="line-222"></span><span>        </span><span class="hs-comment">-- trailing white space.</span><span>
</span><span id="line-223"></span><span>
</span><span id="line-224"></span><span>        </span><span id="symbol"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#symbol"><span class="hs-identifier hs-var hs-var">symbol</span></a></span></span><span>           </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-225"></span><span>
</span><span id="line-226"></span><span>        </span><span class="hs-comment">-- | @lexeme p@ first applies parser @p@ and then the 'whiteSpace'</span><span>
</span><span id="line-227"></span><span>        </span><span class="hs-comment">-- parser, returning the value of @p@. Every lexical</span><span>
</span><span id="line-228"></span><span>        </span><span class="hs-comment">-- token (lexeme) is defined using @lexeme@, this way every parse</span><span>
</span><span id="line-229"></span><span>        </span><span class="hs-comment">-- starts at a point without white space. Parsers that use @lexeme@ are</span><span>
</span><span id="line-230"></span><span>        </span><span class="hs-comment">-- called /lexeme/ parsers in this document.</span><span>
</span><span id="line-231"></span><span>        </span><span class="hs-comment">--</span><span>
</span><span id="line-232"></span><span>        </span><span class="hs-comment">-- The only point where the 'whiteSpace' parser should be</span><span>
</span><span id="line-233"></span><span>        </span><span class="hs-comment">-- called explicitly is the start of the main parser in order to skip</span><span>
</span><span id="line-234"></span><span>        </span><span class="hs-comment">-- any leading white space.</span><span>
</span><span id="line-235"></span><span>        </span><span class="hs-comment">--</span><span>
</span><span id="line-236"></span><span>        </span><span class="hs-comment">-- &gt;    mainParser  = do{ whiteSpace</span><span>
</span><span id="line-237"></span><span>        </span><span class="hs-comment">-- &gt;                     ; ds &lt;- many (lexeme digit)</span><span>
</span><span id="line-238"></span><span>        </span><span class="hs-comment">-- &gt;                     ; eof</span><span>
</span><span id="line-239"></span><span>        </span><span class="hs-comment">-- &gt;                     ; return (sum ds)</span><span>
</span><span id="line-240"></span><span>        </span><span class="hs-comment">-- &gt;                     }</span><span>
</span><span id="line-241"></span><span>
</span><span id="line-242"></span><span>        </span><span id="lexeme"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#lexeme"><span class="hs-identifier hs-var hs-var">lexeme</span></a></span></span><span>           </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062210"><span class="annot"><a href="#local-6989586621679062210"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062210"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062210"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-243"></span><span>
</span><span id="line-244"></span><span>        </span><span class="hs-comment">-- | Parses any white space. White space consists of /zero/ or more</span><span>
</span><span id="line-245"></span><span>        </span><span class="hs-comment">-- occurrences of a 'space', a line comment or a block (multi</span><span>
</span><span id="line-246"></span><span>        </span><span class="hs-comment">-- line) comment. Block comments may be nested. How comments are</span><span>
</span><span id="line-247"></span><span>        </span><span class="hs-comment">-- started and ended is defined in the 'LanguageDef'</span><span>
</span><span id="line-248"></span><span>        </span><span class="hs-comment">-- that is passed to 'makeTokenParser'.</span><span>
</span><span id="line-249"></span><span>
</span><span id="line-250"></span><span>        </span><span id="whiteSpace"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *). GenTokenParser s u m -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#whiteSpace"><span class="hs-identifier hs-var hs-var">whiteSpace</span></a></span></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-251"></span><span>
</span><span id="line-252"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @parens p@ parses @p@ enclosed in parenthesis,</span><span>
</span><span id="line-253"></span><span>        </span><span class="hs-comment">-- returning the value of @p@.</span><span>
</span><span id="line-254"></span><span>
</span><span id="line-255"></span><span>        </span><span id="parens"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#parens"><span class="hs-identifier hs-var hs-var">parens</span></a></span></span><span>           </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062198"><span class="annot"><a href="#local-6989586621679062198"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062198"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062198"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-256"></span><span>
</span><span id="line-257"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @braces p@ parses @p@ enclosed in braces (\'{\' and</span><span>
</span><span id="line-258"></span><span>        </span><span class="hs-comment">-- \'}\'), returning the value of @p@.</span><span>
</span><span id="line-259"></span><span>
</span><span id="line-260"></span><span>        </span><span id="braces"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#braces"><span class="hs-identifier hs-var hs-var">braces</span></a></span></span><span>           </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062193"><span class="annot"><a href="#local-6989586621679062193"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062193"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062193"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @angles p@ parses @p@ enclosed in angle brackets (\'\&lt;\'</span><span>
</span><span id="line-263"></span><span>        </span><span class="hs-comment">-- and \'&gt;\'), returning the value of @p@.</span><span>
</span><span id="line-264"></span><span>
</span><span id="line-265"></span><span>        </span><span id="angles"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#angles"><span class="hs-identifier hs-var hs-var">angles</span></a></span></span><span>           </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062188"><span class="annot"><a href="#local-6989586621679062188"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062188"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062188"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @brackets p@ parses @p@ enclosed in brackets (\'[\'</span><span>
</span><span id="line-268"></span><span>        </span><span class="hs-comment">-- and \']\'), returning the value of @p@.</span><span>
</span><span id="line-269"></span><span>
</span><span id="line-270"></span><span>        </span><span id="brackets"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#brackets"><span class="hs-identifier hs-var hs-var">brackets</span></a></span></span><span>         </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062183"><span class="annot"><a href="#local-6989586621679062183"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062183"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062183"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-271"></span><span>
</span><span id="line-272"></span><span>        </span><span class="hs-comment">-- | DEPRECATED: Use 'brackets'.</span><span>
</span><span id="line-273"></span><span>
</span><span id="line-274"></span><span>        </span><span id="squares"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#squares"><span class="hs-identifier hs-var hs-var">squares</span></a></span></span><span>          </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062178"><span class="annot"><a href="#local-6989586621679062178"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062178"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062178"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-275"></span><span>
</span><span id="line-276"></span><span>        </span><span class="hs-comment">-- | Lexeme parser |semi| parses the character \';\' and skips any</span><span>
</span><span id="line-277"></span><span>        </span><span class="hs-comment">-- trailing white space. Returns the string \&quot;;\&quot;.</span><span>
</span><span id="line-278"></span><span>
</span><span id="line-279"></span><span>        </span><span id="semi"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#semi"><span class="hs-identifier hs-var hs-var">semi</span></a></span></span><span>             </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-280"></span><span>
</span><span id="line-281"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @comma@ parses the character \',\' and skips any</span><span>
</span><span id="line-282"></span><span>        </span><span class="hs-comment">-- trailing white space. Returns the string \&quot;,\&quot;.</span><span>
</span><span id="line-283"></span><span>
</span><span id="line-284"></span><span>        </span><span id="comma"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#comma"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span>            </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-285"></span><span>
</span><span id="line-286"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @colon@ parses the character \':\' and skips any</span><span>
</span><span id="line-287"></span><span>        </span><span class="hs-comment">-- trailing white space. Returns the string \&quot;:\&quot;.</span><span>
</span><span id="line-288"></span><span>
</span><span id="line-289"></span><span>        </span><span id="colon"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#colon"><span class="hs-identifier hs-var hs-var">colon</span></a></span></span><span>            </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-290"></span><span>
</span><span id="line-291"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @dot@ parses the character \'.\' and skips any</span><span>
</span><span id="line-292"></span><span>        </span><span class="hs-comment">-- trailing white space. Returns the string \&quot;.\&quot;.</span><span>
</span><span id="line-293"></span><span>
</span><span id="line-294"></span><span>        </span><span id="dot"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#dot"><span class="hs-identifier hs-var hs-var">dot</span></a></span></span><span>              </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-295"></span><span>
</span><span id="line-296"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @semiSep p@ parses /zero/ or more occurrences of @p@</span><span>
</span><span id="line-297"></span><span>        </span><span class="hs-comment">-- separated by 'semi'. Returns a list of values returned by</span><span>
</span><span id="line-298"></span><span>        </span><span class="hs-comment">-- @p@.</span><span>
</span><span id="line-299"></span><span>
</span><span id="line-300"></span><span>        </span><span id="semiSep"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#semiSep"><span class="hs-identifier hs-var hs-var">semiSep</span></a></span></span><span>          </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062165"><span class="annot"><a href="#local-6989586621679062165"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062165"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679062165"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span>
</span><span id="line-301"></span><span>
</span><span id="line-302"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @semiSep1 p@ parses /one/ or more occurrences of @p@</span><span>
</span><span id="line-303"></span><span>        </span><span class="hs-comment">-- separated by 'semi'. Returns a list of values returned by @p@.</span><span>
</span><span id="line-304"></span><span>
</span><span id="line-305"></span><span>        </span><span id="semiSep1"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#semiSep1"><span class="hs-identifier hs-var hs-var">semiSep1</span></a></span></span><span>         </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062156"><span class="annot"><a href="#local-6989586621679062156"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062156"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679062156"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span>
</span><span id="line-306"></span><span>
</span><span id="line-307"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @commaSep p@ parses /zero/ or more occurrences of</span><span>
</span><span id="line-308"></span><span>        </span><span class="hs-comment">-- @p@ separated by 'comma'. Returns a list of values returned</span><span>
</span><span id="line-309"></span><span>        </span><span class="hs-comment">-- by @p@.</span><span>
</span><span id="line-310"></span><span>
</span><span id="line-311"></span><span>        </span><span id="commaSep"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#commaSep"><span class="hs-identifier hs-var hs-var">commaSep</span></a></span></span><span>         </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062151"><span class="annot"><a href="#local-6989586621679062151"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062151"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679062151"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span class="hs-special">,</span><span>
</span><span id="line-312"></span><span>
</span><span id="line-313"></span><span>        </span><span class="hs-comment">-- | Lexeme parser @commaSep1 p@ parses /one/ or more occurrences of</span><span>
</span><span id="line-314"></span><span>        </span><span class="hs-comment">-- @p@ separated by 'comma'. Returns a list of values returned</span><span>
</span><span id="line-315"></span><span>        </span><span class="hs-comment">-- by @p@.</span><span>
</span><span id="line-316"></span><span>
</span><span id="line-317"></span><span>        </span><span id="commaSep1"><span class="annot"><span class="annottext">forall s u (m :: * -&gt; *).
GenTokenParser s u m
-&gt; forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#commaSep1"><span class="hs-identifier hs-var hs-var">commaSep1</span></a></span></span><span>        </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679062146"><span class="annot"><a href="#local-6989586621679062146"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062146"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062256"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062255"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062254"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679062146"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-318"></span><span>    </span><span class="hs-special">}</span><span class="hs-cpp">
#if MIN_VERSION_base(4,7,0)
</span><span>    </span><span class="hs-keyword">deriving</span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Typeable"><span class="hs-identifier hs-type">Typeable</span></a></span><span> </span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-323"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-324"></span><span class="hs-comment">-- Given a LanguageDef, create a token parser.</span><span>
</span><span id="line-325"></span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-326"></span><span>
</span><span id="line-327"></span><span class="hs-comment">-- | The expression @makeTokenParser language@ creates a 'GenTokenParser'</span><span>
</span><span id="line-328"></span><span class="hs-comment">-- record that contains lexical parsers that are</span><span>
</span><span id="line-329"></span><span class="hs-comment">-- defined using the definitions in the @language@ record.</span><span>
</span><span id="line-330"></span><span class="hs-comment">--</span><span>
</span><span id="line-331"></span><span class="hs-comment">-- The use of this function is quite stylized - one imports the</span><span>
</span><span id="line-332"></span><span class="hs-comment">-- appropiate language definition and selects the lexical parsers that</span><span>
</span><span id="line-333"></span><span class="hs-comment">-- are needed from the resulting 'GenTokenParser'.</span><span>
</span><span id="line-334"></span><span class="hs-comment">--</span><span>
</span><span id="line-335"></span><span class="hs-comment">-- &gt;  module Main where</span><span>
</span><span id="line-336"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-337"></span><span class="hs-comment">-- &gt;  import Text.Parsec</span><span>
</span><span id="line-338"></span><span class="hs-comment">-- &gt;  import qualified Text.Parsec.Token as P</span><span>
</span><span id="line-339"></span><span class="hs-comment">-- &gt;  import Text.Parsec.Language (haskellDef)</span><span>
</span><span id="line-340"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-341"></span><span class="hs-comment">-- &gt;  -- The parser</span><span>
</span><span id="line-342"></span><span class="hs-comment">-- &gt;  ...</span><span>
</span><span id="line-343"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-344"></span><span class="hs-comment">-- &gt;  expr  =   parens expr</span><span>
</span><span id="line-345"></span><span class="hs-comment">-- &gt;        &lt;|&gt; identifier</span><span>
</span><span id="line-346"></span><span class="hs-comment">-- &gt;        &lt;|&gt; ...</span><span>
</span><span id="line-347"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-348"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-349"></span><span class="hs-comment">-- &gt;  -- The lexer</span><span>
</span><span id="line-350"></span><span class="hs-comment">-- &gt;  lexer       = P.makeTokenParser haskellDef</span><span>
</span><span id="line-351"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-352"></span><span class="hs-comment">-- &gt;  parens      = P.parens lexer</span><span>
</span><span id="line-353"></span><span class="hs-comment">-- &gt;  braces      = P.braces lexer</span><span>
</span><span id="line-354"></span><span class="hs-comment">-- &gt;  identifier  = P.identifier lexer</span><span>
</span><span id="line-355"></span><span class="hs-comment">-- &gt;  reserved    = P.reserved lexer</span><span>
</span><span id="line-356"></span><span class="hs-comment">-- &gt;  ...</span><span>
</span><span id="line-357"></span><span>
</span><span id="line-358"></span><span id="local-6989586621679062142"><span id="local-6989586621679062144"><span id="local-6989586621679062145"><span class="annot"><a href="Text.Parsec.Token.html#makeTokenParser"><span class="hs-identifier hs-type">makeTokenParser</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Parsec.Prim.html#Stream"><span class="hs-identifier hs-type">Stream</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062145"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062144"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span class="hs-special">)</span><span>
</span><span id="line-359"></span><span>                </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenLanguageDef"><span class="hs-identifier hs-type">GenLanguageDef</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062145"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062142"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062144"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#GenTokenParser"><span class="hs-identifier hs-type">GenTokenParser</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062145"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062142"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679062144"><span class="hs-identifier hs-type">m</span></a></span></span></span></span><span>
</span><span id="line-360"></span><span class="hs-pragma">{-# INLINABLE</span><span> </span><span class="annot"><a href="Text.Parsec.Token.html#makeTokenParser"><span class="hs-pragma hs-type">makeTokenParser</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-361"></span><span id="makeTokenParser"><span class="annot"><span class="annottext">makeTokenParser :: forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
GenLanguageDef s u m -&gt; GenTokenParser s u m
</span><a href="Text.Parsec.Token.html#makeTokenParser"><span class="hs-identifier hs-var hs-var">makeTokenParser</span></a></span></span><span> </span><span id="local-6989586621679061841"><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span></span><span>
</span><span id="line-362"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TokenParser :: forall s u (m :: * -&gt; *).
ParsecT s u m String
-&gt; (String -&gt; ParsecT s u m ())
-&gt; ParsecT s u m String
-&gt; (String -&gt; ParsecT s u m ())
-&gt; ParsecT s u m Char
-&gt; ParsecT s u m String
-&gt; ParsecT s u m Integer
-&gt; ParsecT s u m Integer
-&gt; ParsecT s u m Double
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m Integer
-&gt; ParsecT s u m Integer
-&gt; ParsecT s u m Integer
-&gt; (String -&gt; ParsecT s u m String)
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; ParsecT s u m ()
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m a)
-&gt; ParsecT s u m String
-&gt; ParsecT s u m String
-&gt; ParsecT s u m String
-&gt; ParsecT s u m String
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m [a])
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m [a])
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m [a])
-&gt; (forall a. ParsecT s u m a -&gt; ParsecT s u m [a])
-&gt; GenTokenParser s u m
</span><a href="Text.Parsec.Token.html#TokenParser"><span class="hs-identifier hs-type">TokenParser</span></a></span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">identifier :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#identifier"><span class="hs-identifier hs-var">identifier</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
</span><a href="#local-6989586621679061840"><span class="hs-identifier hs-var">identifier</span></a></span><span>
</span><span id="line-363"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">reserved :: String -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#reserved"><span class="hs-identifier hs-var">reserved</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061839"><span class="hs-identifier hs-var">reserved</span></a></span><span>
</span><span id="line-364"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">operator :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#operator"><span class="hs-identifier hs-var">operator</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
</span><a href="#local-6989586621679061838"><span class="hs-identifier hs-var">operator</span></a></span><span>
</span><span id="line-365"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">reservedOp :: String -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#reservedOp"><span class="hs-identifier hs-var">reservedOp</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061837"><span class="hs-identifier hs-var">reservedOp</span></a></span><span>
</span><span id="line-366"></span><span>
</span><span id="line-367"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">charLiteral :: ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#charLiteral"><span class="hs-identifier hs-var">charLiteral</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061836"><span class="hs-identifier hs-var">charLiteral</span></a></span><span>
</span><span id="line-368"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">stringLiteral :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#stringLiteral"><span class="hs-identifier hs-var">stringLiteral</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061835"><span class="hs-identifier hs-var">stringLiteral</span></a></span><span>
</span><span id="line-369"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">natural :: ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#natural"><span class="hs-identifier hs-var">natural</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061834"><span class="hs-identifier hs-var">natural</span></a></span><span>
</span><span id="line-370"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">integer :: ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#integer"><span class="hs-identifier hs-var">integer</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061833"><span class="hs-identifier hs-var">integer</span></a></span><span>
</span><span id="line-371"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">float :: ParsecT s u m Double
</span><a href="Text.Parsec.Token.html#float"><span class="hs-identifier hs-var">float</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Double
forall {u}. ParsecT s u m Double
</span><a href="#local-6989586621679061832"><span class="hs-identifier hs-var">float</span></a></span><span>
</span><span id="line-372"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">naturalOrFloat :: ParsecT s u m (Either Integer Double)
</span><a href="Text.Parsec.Token.html#naturalOrFloat"><span class="hs-identifier hs-var">naturalOrFloat</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061831"><span class="hs-identifier hs-var">naturalOrFloat</span></a></span><span>
</span><span id="line-373"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">decimal :: ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#decimal"><span class="hs-identifier hs-var">decimal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span>
</span><span id="line-374"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">hexadecimal :: ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#hexadecimal"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061829"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span>
</span><span id="line-375"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">octal :: ParsecT s u m Integer
</span><a href="Text.Parsec.Token.html#octal"><span class="hs-identifier hs-var">octal</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061828"><span class="hs-identifier hs-var">octal</span></a></span><span>
</span><span id="line-376"></span><span>
</span><span id="line-377"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">symbol :: String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Token.html#symbol"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span>
</span><span id="line-378"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">lexeme :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#lexeme"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span>
</span><span id="line-379"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">whiteSpace :: ParsecT s u m ()
</span><a href="Text.Parsec.Token.html#whiteSpace"><span class="hs-identifier hs-var">whiteSpace</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061825"><span class="hs-identifier hs-var">whiteSpace</span></a></span><span>
</span><span id="line-380"></span><span>
</span><span id="line-381"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">parens :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061824"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-382"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">braces :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#braces"><span class="hs-identifier hs-var">braces</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061822"><span class="hs-identifier hs-var">braces</span></a></span><span>
</span><span id="line-383"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">angles :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#angles"><span class="hs-identifier hs-var">angles</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061820"><span class="hs-identifier hs-var">angles</span></a></span><span>
</span><span id="line-384"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">brackets :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#brackets"><span class="hs-identifier hs-var">brackets</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061818"><span class="hs-identifier hs-var">brackets</span></a></span><span>
</span><span id="line-385"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">squares :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Token.html#squares"><span class="hs-identifier hs-var">squares</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061818"><span class="hs-identifier hs-var">brackets</span></a></span><span>
</span><span id="line-386"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">semi :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#semi"><span class="hs-identifier hs-var">semi</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061815"><span class="hs-identifier hs-var">semi</span></a></span><span>
</span><span id="line-387"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">comma :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#comma"><span class="hs-identifier hs-var">comma</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061814"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-388"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">colon :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#colon"><span class="hs-identifier hs-var">colon</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061813"><span class="hs-identifier hs-var">colon</span></a></span><span>
</span><span id="line-389"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">dot :: ParsecT s u m String
</span><a href="Text.Parsec.Token.html#dot"><span class="hs-identifier hs-var">dot</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061812"><span class="hs-identifier hs-var">dot</span></a></span><span>
</span><span id="line-390"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">semiSep :: forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#semiSep"><span class="hs-identifier hs-var">semiSep</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061811"><span class="hs-identifier hs-var">semiSep</span></a></span><span>
</span><span id="line-391"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">semiSep1 :: forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#semiSep1"><span class="hs-identifier hs-var">semiSep1</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061809"><span class="hs-identifier hs-var">semiSep1</span></a></span><span>
</span><span id="line-392"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">commaSep :: forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#commaSep"><span class="hs-identifier hs-var">commaSep</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061807"><span class="hs-identifier hs-var">commaSep</span></a></span><span>
</span><span id="line-393"></span><span>                 </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">commaSep1 :: forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Token.html#commaSep1"><span class="hs-identifier hs-var">commaSep1</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">forall a. ParsecT s u m a -&gt; ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061805"><span class="hs-identifier hs-var">commaSep1</span></a></span><span>
</span><span id="line-394"></span><span>                 </span><span class="hs-special">}</span><span>
</span><span id="line-395"></span><span>    </span><span class="hs-keyword">where</span><span>
</span><span id="line-396"></span><span>
</span><span id="line-397"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-398"></span><span>    </span><span class="hs-comment">-- Bracketing</span><span>
</span><span id="line-399"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-400"></span><span>    </span><span id="local-6989586621679061824"><span class="annot"><span class="annottext">parens :: ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061824"><span class="hs-identifier hs-var hs-var">parens</span></a></span></span><span> </span><span id="local-6989586621679061801"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061801"><span class="hs-identifier hs-var">p</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
-&gt; ParsecT s u m String -&gt; ParsecT s u m a -&gt; ParsecT s u m a
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;(&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;)&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061801"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-401"></span><span>    </span><span id="local-6989586621679061822"><span class="annot"><span class="annottext">braces :: ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061822"><span class="hs-identifier hs-var hs-var">braces</span></a></span></span><span> </span><span id="local-6989586621679061797"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061797"><span class="hs-identifier hs-var">p</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
-&gt; ParsecT s u m String -&gt; ParsecT s u m a -&gt; ParsecT s u m a
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;{&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;}&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061797"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-402"></span><span>    </span><span id="local-6989586621679061820"><span class="annot"><span class="annottext">angles :: ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061820"><span class="hs-identifier hs-var hs-var">angles</span></a></span></span><span> </span><span id="local-6989586621679061794"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061794"><span class="hs-identifier hs-var">p</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
-&gt; ParsecT s u m String -&gt; ParsecT s u m a -&gt; ParsecT s u m a
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&lt;&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&gt;&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061794"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-403"></span><span>    </span><span id="local-6989586621679061818"><span class="annot"><span class="annottext">brackets :: ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061818"><span class="hs-identifier hs-var hs-var">brackets</span></a></span></span><span> </span><span id="local-6989586621679061791"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061791"><span class="hs-identifier hs-var">p</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
-&gt; ParsecT s u m String -&gt; ParsecT s u m a -&gt; ParsecT s u m a
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;[&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;]&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061791"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-404"></span><span>
</span><span id="line-405"></span><span>    </span><span id="local-6989586621679061815"><span class="annot"><span class="annottext">semi :: ParsecT s u m String
</span><a href="#local-6989586621679061815"><span class="hs-identifier hs-var hs-var">semi</span></a></span></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;;&quot;</span></span><span>
</span><span id="line-406"></span><span>    </span><span id="local-6989586621679061814"><span class="annot"><span class="annottext">comma :: ParsecT s u m String
</span><a href="#local-6989586621679061814"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;,&quot;</span></span><span>
</span><span id="line-407"></span><span>    </span><span id="local-6989586621679061812"><span class="annot"><span class="annottext">dot :: ParsecT s u m String
</span><a href="#local-6989586621679061812"><span class="hs-identifier hs-var hs-var">dot</span></a></span></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;.&quot;</span></span><span>
</span><span id="line-408"></span><span>    </span><span id="local-6989586621679061813"><span class="annot"><span class="annottext">colon :: ParsecT s u m String
</span><a href="#local-6989586621679061813"><span class="hs-identifier hs-var hs-var">colon</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall {u}. String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var">symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;:&quot;</span></span><span>
</span><span id="line-409"></span><span>
</span><span id="line-410"></span><span>    </span><span id="local-6989586621679061807"><span class="annot"><span class="annottext">commaSep :: ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061807"><span class="hs-identifier hs-var hs-var">commaSep</span></a></span></span><span> </span><span id="local-6989586621679061788"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061788"><span class="hs-identifier hs-var">p</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m String -&gt; ParsecT s u m [a]
forall s (m :: * -&gt; *) t u a sep.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m sep -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#sepBy"><span class="hs-identifier hs-var">sepBy</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061788"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061814"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-411"></span><span>    </span><span id="local-6989586621679061811"><span class="annot"><span class="annottext">semiSep :: ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061811"><span class="hs-identifier hs-var hs-var">semiSep</span></a></span></span><span> </span><span id="local-6989586621679061784"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061784"><span class="hs-identifier hs-var">p</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m String -&gt; ParsecT s u m [a]
forall s (m :: * -&gt; *) t u a sep.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m sep -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#sepBy"><span class="hs-identifier hs-var">sepBy</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061784"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061815"><span class="hs-identifier hs-var">semi</span></a></span><span>
</span><span id="line-412"></span><span>
</span><span id="line-413"></span><span>    </span><span id="local-6989586621679061805"><span class="annot"><span class="annottext">commaSep1 :: ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061805"><span class="hs-identifier hs-var hs-var">commaSep1</span></a></span></span><span> </span><span id="local-6989586621679061781"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061781"><span class="hs-identifier hs-var">p</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m String -&gt; ParsecT s u m [a]
forall s (m :: * -&gt; *) t u a sep.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m sep -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#sepBy1"><span class="hs-identifier hs-var">sepBy1</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061781"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061814"><span class="hs-identifier hs-var">comma</span></a></span><span>
</span><span id="line-414"></span><span>    </span><span id="local-6989586621679061809"><span class="annot"><span class="annottext">semiSep1 :: ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="#local-6989586621679061809"><span class="hs-identifier hs-var hs-var">semiSep1</span></a></span></span><span> </span><span id="local-6989586621679061777"><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061777"><span class="hs-identifier hs-var">p</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m String -&gt; ParsecT s u m [a]
forall s (m :: * -&gt; *) t u a sep.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m sep -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#sepBy1"><span class="hs-identifier hs-var">sepBy1</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
</span><a href="#local-6989586621679061777"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061815"><span class="hs-identifier hs-var">semi</span></a></span><span>
</span><span id="line-415"></span><span>
</span><span id="line-416"></span><span>
</span><span id="line-417"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-418"></span><span>    </span><span class="hs-comment">-- Chars &amp; Strings</span><span>
</span><span id="line-419"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-420"></span><span>    </span><span id="local-6989586621679061836"><span class="annot"><span class="annottext">charLiteral :: ParsecT s u m Char
</span><a href="#local-6989586621679061836"><span class="hs-identifier hs-var hs-var">charLiteral</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m Char
-&gt; ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\''</span></span><span class="hs-special">)</span><span>
</span><span id="line-421"></span><span>                                      </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\''</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of character&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-422"></span><span>                                      </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061771"><span class="hs-identifier hs-var">characterChar</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-423"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;character&quot;</span></span><span>
</span><span id="line-424"></span><span>
</span><span id="line-425"></span><span>    </span><span id="local-6989586621679061771"><span class="annot"><span class="annottext">characterChar :: ParsecT s u m Char
</span><a href="#local-6989586621679061771"><span class="hs-identifier hs-var hs-var">characterChar</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061770"><span class="hs-identifier hs-var">charLetter</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061768"><span class="hs-identifier hs-var">charEscape</span></a></span><span>
</span><span id="line-426"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;literal character&quot;</span></span><span>
</span><span id="line-427"></span><span>
</span><span id="line-428"></span><span>    </span><span id="local-6989586621679061768"><span class="annot"><span class="annottext">charEscape :: ParsecT s u m Char
</span><a href="#local-6989586621679061768"><span class="hs-identifier hs-var hs-var">charEscape</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061764"><span class="hs-identifier hs-var">escapeCode</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-429"></span><span>    </span><span id="local-6989586621679061770"><span class="annot"><span class="annottext">charLetter :: ParsecT s u m Char
</span><a href="#local-6989586621679061770"><span class="hs-identifier hs-var hs-var">charLetter</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679061756"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061756"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061756"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\''</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061756"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061756"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\026'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-430"></span><span>
</span><span id="line-431"></span><span>
</span><span id="line-432"></span><span>
</span><span id="line-433"></span><span>    </span><span id="local-6989586621679061835"><span class="annot"><span class="annottext">stringLiteral :: ParsecT s u m String
</span><a href="#local-6989586621679061835"><span class="hs-identifier hs-var hs-var">stringLiteral</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-434"></span><span>                      </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061745"><span class="annot"><span class="annottext">[Maybe Char]
</span><a href="#local-6989586621679061745"><span class="hs-identifier hs-var">str</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
-&gt; ParsecT s u m Char
-&gt; ParsecT s u m [Maybe Char]
-&gt; ParsecT s u m [Maybe Char]
forall s (m :: * -&gt; *) t u open close a.
Stream s m t =&gt;
ParsecT s u m open
-&gt; ParsecT s u m close -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#between"><span class="hs-identifier hs-var">between</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span>
</span><span id="line-435"></span><span>                                         </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of string&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-436"></span><span>                                         </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char) -&gt; ParsecT s u m [Maybe Char]
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Prim.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char)
forall {u}. ParsecT s u m (Maybe Char)
</span><a href="#local-6989586621679061743"><span class="hs-identifier hs-var">stringChar</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-437"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Maybe Char -&gt; String -&gt; String)
-&gt; String -&gt; [Maybe Char] -&gt; String
forall (t :: * -&gt; *) a b.
Foldable t =&gt;
(a -&gt; b -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldr"><span class="hs-identifier hs-var">foldr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(String -&gt; String)
-&gt; (Char -&gt; String -&gt; String) -&gt; Maybe Char -&gt; String -&gt; String
forall b a. b -&gt; (a -&gt; b) -&gt; Maybe a -&gt; b
</span><a href="../../base/src/Data.Maybe.html#maybe"><span class="hs-identifier hs-var">maybe</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span> </span><span class="annot"><span class="annottext">[Maybe Char]
</span><a href="#local-6989586621679061745"><span class="hs-identifier hs-var">str</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-438"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-439"></span><span>                      </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;literal string&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-440"></span><span>
</span><span id="line-441"></span><span>    </span><span id="local-6989586621679061743"><span class="annot"><span class="annottext">stringChar :: ParsecT s u m (Maybe Char)
</span><a href="#local-6989586621679061743"><span class="hs-identifier hs-var hs-var">stringChar</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span>   </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061737"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061737"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061736"><span class="hs-identifier hs-var">stringLetter</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; ParsecT s u m (Maybe Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Maybe Char
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061737"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-442"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char)
-&gt; ParsecT s u m (Maybe Char) -&gt; ParsecT s u m (Maybe Char)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char)
forall {u}. ParsecT s u m (Maybe Char)
</span><a href="#local-6989586621679061735"><span class="hs-identifier hs-var">stringEscape</span></a></span><span>
</span><span id="line-443"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char) -&gt; String -&gt; ParsecT s u m (Maybe Char)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;string character&quot;</span></span><span>
</span><span id="line-444"></span><span>
</span><span id="line-445"></span><span>    </span><span id="local-6989586621679061736"><span class="annot"><span class="annottext">stringLetter :: ParsecT s u m Char
</span><a href="#local-6989586621679061736"><span class="hs-identifier hs-var hs-var">stringLetter</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679061730"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061730"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061730"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&quot;'</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061730"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061730"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\026'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-446"></span><span>
</span><span id="line-447"></span><span>    </span><span id="local-6989586621679061735"><span class="annot"><span class="annottext">stringEscape :: ParsecT s u m (Maybe Char)
</span><a href="#local-6989586621679061735"><span class="hs-identifier hs-var hs-var">stringEscape</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span>
</span><span id="line-448"></span><span>                        </span><span class="hs-special">;</span><span>     </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061721"><span class="hs-identifier hs-var">escapeGap</span></a></span><span>  </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; ParsecT s u m (Maybe Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Char
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-449"></span><span>                          </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char)
-&gt; ParsecT s u m (Maybe Char) -&gt; ParsecT s u m (Maybe Char)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061720"><span class="hs-identifier hs-var">escapeEmpty</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; ParsecT s u m (Maybe Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Char
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-450"></span><span>                          </span><span class="annot"><span class="annottext">ParsecT s u m (Maybe Char)
-&gt; ParsecT s u m (Maybe Char) -&gt; ParsecT s u m (Maybe Char)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061719"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061719"><span class="hs-identifier hs-var">esc</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061764"><span class="hs-identifier hs-var">escapeCode</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Maybe Char -&gt; ParsecT s u m (Maybe Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Maybe Char
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061719"><span class="hs-identifier hs-var">esc</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-451"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-452"></span><span>
</span><span id="line-453"></span><span>    </span><span id="local-6989586621679061720"><span class="annot"><span class="annottext">escapeEmpty :: ParsecT s u m Char
</span><a href="#local-6989586621679061720"><span class="hs-identifier hs-var hs-var">escapeEmpty</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&amp;'</span></span><span>
</span><span id="line-454"></span><span>    </span><span id="local-6989586621679061721"><span class="annot"><span class="annottext">escapeGap :: ParsecT s u m Char
</span><a href="#local-6989586621679061721"><span class="hs-identifier hs-var hs-var">escapeGap</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#many1"><span class="hs-identifier hs-var">many1</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#space"><span class="hs-identifier hs-var">space</span></a></span><span>
</span><span id="line-455"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of string gap&quot;</span></span><span>
</span><span id="line-456"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-457"></span><span>
</span><span id="line-458"></span><span>
</span><span id="line-459"></span><span>
</span><span id="line-460"></span><span>    </span><span class="hs-comment">-- escape codes</span><span>
</span><span id="line-461"></span><span>    </span><span id="local-6989586621679061764"><span class="annot"><span class="annottext">escapeCode :: ParsecT s u m Char
</span><a href="#local-6989586621679061764"><span class="hs-identifier hs-var hs-var">escapeCode</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061711"><span class="hs-identifier hs-var">charEsc</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061710"><span class="hs-identifier hs-var">charNum</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061709"><span class="hs-identifier hs-var">charAscii</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall {u}. ParsecT s u m Char
</span><a href="#local-6989586621679061708"><span class="hs-identifier hs-var">charControl</span></a></span><span>
</span><span id="line-462"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;escape code&quot;</span></span><span>
</span><span id="line-463"></span><span>
</span><span id="line-464"></span><span>    </span><span id="local-6989586621679061708"><span class="annot"><span class="annottext">charControl :: ParsecT s u m Char
</span><a href="#local-6989586621679061708"><span class="hs-identifier hs-var hs-var">charControl</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'^'</span></span><span>
</span><span id="line-465"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061694"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061694"><span class="hs-identifier hs-var">code</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#upper"><span class="hs-identifier hs-var">upper</span></a></span><span>
</span><span id="line-466"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Char
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061694"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'A'</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-467"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-468"></span><span>
</span><span id="line-469"></span><span>    </span><span id="local-6989586621679061710"><span class="annot"><span class="annottext">charNum :: ParsecT s u m Char
</span><a href="#local-6989586621679061710"><span class="hs-identifier hs-var hs-var">charNum</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061671"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061671"><span class="hs-identifier hs-var">code</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span>
</span><span id="line-470"></span><span>                                  </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'o'</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
forall {s} {m :: * -&gt; *} {t} {u}.
Stream s m t =&gt;
Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var">number</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#octDigit"><span class="hs-identifier hs-var">octDigit</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-471"></span><span>                                  </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'x'</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
forall {s} {m :: * -&gt; *} {t} {u}.
Stream s m t =&gt;
Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var">number</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">16</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-472"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061671"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0x10FFFF</span></span><span>
</span><span id="line-473"></span><span>                          </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;invalid escape sequence&quot;</span></span><span>
</span><span id="line-474"></span><span>                          </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Char
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a. Num a =&gt; Integer -&gt; a
</span><a href="../../base/src/GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061671"><span class="hs-identifier hs-var">code</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-475"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-476"></span><span>
</span><span id="line-477"></span><span>    </span><span id="local-6989586621679061711"><span class="annot"><span class="annottext">charEsc :: ParsecT s u m Char
</span><a href="#local-6989586621679061711"><span class="hs-identifier hs-var hs-var">charEsc</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[ParsecT s u m Char] -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
[ParsecT s u m a] -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#choice"><span class="hs-identifier hs-var">choice</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">((Char, Char) -&gt; ParsecT s u m Char)
-&gt; [(Char, Char)] -&gt; [ParsecT s u m Char]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">(Char, Char) -&gt; ParsecT s u m Char
forall {s} {m :: * -&gt; *} {b} {u}.
Stream s m Char =&gt;
(Char, b) -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061664"><span class="hs-identifier hs-var">parseEsc</span></a></span><span> </span><span class="annot"><span class="annottext">[(Char, Char)]
</span><a href="#local-6989586621679061663"><span class="hs-identifier hs-var">escMap</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-478"></span><span>                    </span><span class="hs-keyword">where</span><span>
</span><span id="line-479"></span><span>                      </span><span id="local-6989586621679061664"><span class="annot"><span class="annottext">parseEsc :: (Char, b) -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061664"><span class="hs-identifier hs-var hs-var">parseEsc</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679061658"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061658"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679061657"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061657"><span class="hs-identifier hs-var">code</span></a></span></span><span class="hs-special">)</span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061658"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">b -&gt; ParsecT s u m b
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061657"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-480"></span><span>
</span><span id="line-481"></span><span>    </span><span id="local-6989586621679061709"><span class="annot"><span class="annottext">charAscii :: ParsecT s u m Char
</span><a href="#local-6989586621679061709"><span class="hs-identifier hs-var hs-var">charAscii</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[ParsecT s u m Char] -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
[ParsecT s u m a] -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#choice"><span class="hs-identifier hs-var">choice</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">((String, Char) -&gt; ParsecT s u m Char)
-&gt; [(String, Char)] -&gt; [ParsecT s u m Char]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">(String, Char) -&gt; ParsecT s u m Char
forall {s} {m :: * -&gt; *} {a} {u}.
Stream s m Char =&gt;
(String, a) -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061654"><span class="hs-identifier hs-var">parseAscii</span></a></span><span> </span><span class="annot"><span class="annottext">[(String, Char)]
</span><a href="#local-6989586621679061653"><span class="hs-identifier hs-var">asciiMap</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-482"></span><span>                    </span><span class="hs-keyword">where</span><span>
</span><span id="line-483"></span><span>                      </span><span id="local-6989586621679061654"><span class="annot"><span class="annottext">parseAscii :: (String, a) -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061654"><span class="hs-identifier hs-var hs-var">parseAscii</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679061648"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061648"><span class="hs-identifier hs-var">asc</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679061647"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061647"><span class="hs-identifier hs-var">code</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m a
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061648"><span class="hs-identifier hs-var">asc</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">a -&gt; ParsecT s u m a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061647"><span class="hs-identifier hs-var">code</span></a></span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-484"></span><span>
</span><span id="line-485"></span><span>
</span><span id="line-486"></span><span>    </span><span class="hs-comment">-- escape code tables</span><span>
</span><span id="line-487"></span><span>    </span><span id="local-6989586621679061663"><span class="annot"><span class="annottext">escMap :: [(Char, Char)]
</span><a href="#local-6989586621679061663"><span class="hs-identifier hs-var hs-var">escMap</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; [(Char, Char)]
forall a b. [a] -&gt; [b] -&gt; [(a, b)]
</span><a href="../../base/src/GHC.List.html#zip"><span class="hs-identifier hs-var">zip</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;abfnrtv\\\&quot;\'&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;\a\b\f\n\r\t\v\\\&quot;\'&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-488"></span><span>    </span><span id="local-6989586621679061653"><span class="annot"><span class="annottext">asciiMap :: [(String, Char)]
</span><a href="#local-6989586621679061653"><span class="hs-identifier hs-var hs-var">asciiMap</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String -&gt; [(String, Char)]
forall a b. [a] -&gt; [b] -&gt; [(a, b)]
</span><a href="../../base/src/GHC.List.html#zip"><span class="hs-identifier hs-var">zip</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679061644"><span class="hs-identifier hs-var">ascii3codes</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; [String] -&gt; [String]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679061643"><span class="hs-identifier hs-var">ascii2codes</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061642"><span class="hs-identifier hs-var">ascii3</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061641"><span class="hs-identifier hs-var">ascii2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-489"></span><span>
</span><span id="line-490"></span><span>    </span><span id="local-6989586621679061643"><span class="annot"><span class="annottext">ascii2codes :: [String]
</span><a href="#local-6989586621679061643"><span class="hs-identifier hs-var hs-var">ascii2codes</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;BS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;HT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LF&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;VT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;FF&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CR&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SO&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SI&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;EM&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-491"></span><span>                       </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;FS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;RS&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;US&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SP&quot;</span></span><span class="hs-special">]</span><span>
</span><span id="line-492"></span><span>    </span><span id="local-6989586621679061644"><span class="annot"><span class="annottext">ascii3codes :: [String]
</span><a href="#local-6989586621679061644"><span class="hs-identifier hs-var hs-var">ascii3codes</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NUL&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SOH&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;STX&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ETX&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;EOT&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ENQ&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ACK&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;BEL&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-493"></span><span>                       </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DLE&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC1&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC2&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC3&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DC4&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NAK&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SYN&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ETB&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-494"></span><span>                       </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;CAN&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;SUB&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;ESC&quot;</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;DEL&quot;</span></span><span class="hs-special">]</span><span>
</span><span id="line-495"></span><span>
</span><span id="line-496"></span><span>    </span><span id="local-6989586621679061641"><span class="annot"><span class="annottext">ascii2 :: String
</span><a href="#local-6989586621679061641"><span class="hs-identifier hs-var hs-var">ascii2</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\BS'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\HT'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\LF'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\VT'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\FF'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\CR'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SO'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SI'</span></span><span class="hs-special">,</span><span>
</span><span id="line-497"></span><span>                       </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\EM'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\FS'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\GS'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\RS'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\US'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SP'</span></span><span class="hs-special">]</span><span>
</span><span id="line-498"></span><span>    </span><span id="local-6989586621679061642"><span class="annot"><span class="annottext">ascii3 :: String
</span><a href="#local-6989586621679061642"><span class="hs-identifier hs-var hs-var">ascii3</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\NUL'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SOH'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\STX'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\ETX'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\EOT'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\ENQ'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\ACK'</span></span><span class="hs-special">,</span><span>
</span><span id="line-499"></span><span>                       </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\BEL'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DLE'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DC1'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DC2'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DC3'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DC4'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\NAK'</span></span><span class="hs-special">,</span><span>
</span><span id="line-500"></span><span>                       </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SYN'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\ETB'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\CAN'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\SUB'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\ESC'</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\DEL'</span></span><span class="hs-special">]</span><span>
</span><span id="line-501"></span><span>
</span><span id="line-502"></span><span>
</span><span id="line-503"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-504"></span><span>    </span><span class="hs-comment">-- Numbers</span><span>
</span><span id="line-505"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-506"></span><span>    </span><span id="local-6989586621679061831"><span class="annot"><span class="annottext">naturalOrFloat :: ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061831"><span class="hs-identifier hs-var hs-var">naturalOrFloat</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061640"><span class="hs-identifier hs-var">natFloat</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; String -&gt; ParsecT s u m (Either Integer Double)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;number&quot;</span></span><span>
</span><span id="line-507"></span><span>
</span><span id="line-508"></span><span>    </span><span id="local-6989586621679061832"><span class="annot"><span class="annottext">float :: ParsecT s u m Double
</span><a href="#local-6989586621679061832"><span class="hs-identifier hs-var hs-var">float</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Double -&gt; ParsecT s u m Double
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Double
forall {u}. ParsecT s u m Double
</span><a href="#local-6989586621679061639"><span class="hs-identifier hs-var">floating</span></a></span><span>   </span><span class="annot"><span class="annottext">ParsecT s u m Double -&gt; String -&gt; ParsecT s u m Double
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;float&quot;</span></span><span>
</span><span id="line-509"></span><span>    </span><span id="local-6989586621679061833"><span class="annot"><span class="annottext">integer :: ParsecT s u m Integer
</span><a href="#local-6989586621679061833"><span class="hs-identifier hs-var hs-var">integer</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061638"><span class="hs-identifier hs-var">int</span></a></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; String -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;integer&quot;</span></span><span>
</span><span id="line-510"></span><span>    </span><span id="local-6989586621679061834"><span class="annot"><span class="annottext">natural :: ParsecT s u m Integer
</span><a href="#local-6989586621679061834"><span class="hs-identifier hs-var hs-var">natural</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061637"><span class="hs-identifier hs-var">nat</span></a></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; String -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;natural&quot;</span></span><span>
</span><span id="line-511"></span><span>
</span><span id="line-512"></span><span>
</span><span id="line-513"></span><span>    </span><span class="hs-comment">-- floats</span><span>
</span><span id="line-514"></span><span>    </span><span id="local-6989586621679061639"><span class="annot"><span class="annottext">floating :: ParsecT s u m Double
</span><a href="#local-6989586621679061639"><span class="hs-identifier hs-var hs-var">floating</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061631"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061631"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span>
</span><span id="line-515"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Double
forall {a} {a} {u}. (Read a, Show a) =&gt; a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061630"><span class="hs-identifier hs-var">fractExponent</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061631"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-516"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-517"></span><span>
</span><span id="line-518"></span><span>
</span><span id="line-519"></span><span>    </span><span id="local-6989586621679061640"><span class="annot"><span class="annottext">natFloat :: ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061640"><span class="hs-identifier hs-var hs-var">natFloat</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'0'</span></span><span>
</span><span id="line-520"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061627"><span class="hs-identifier hs-var">zeroNumFloat</span></a></span><span>
</span><span id="line-521"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-522"></span><span>                      </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061626"><span class="hs-identifier hs-var">decimalFloat</span></a></span><span>
</span><span id="line-523"></span><span>
</span><span id="line-524"></span><span>    </span><span id="local-6989586621679061627"><span class="annot"><span class="annottext">zeroNumFloat :: ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061627"><span class="hs-identifier hs-var hs-var">zeroNumFloat</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span>  </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061619"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061619"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061829"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061828"><span class="hs-identifier hs-var">octal</span></a></span><span>
</span><span id="line-525"></span><span>                         </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Either Integer Double -&gt; ParsecT s u m (Either Integer Double)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Either Integer Double
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061619"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-526"></span><span>                         </span><span class="hs-special">}</span><span>
</span><span id="line-527"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061626"><span class="hs-identifier hs-var">decimalFloat</span></a></span><span>
</span><span id="line-528"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m (Either Integer Double)
forall {b} {a} {u} {a}.
(Read b, Show a) =&gt;
a -&gt; ParsecT s u m (Either a b)
</span><a href="#local-6989586621679061618"><span class="hs-identifier hs-var">fractFloat</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span class="hs-special">)</span><span>
</span><span id="line-529"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Either Integer Double -&gt; ParsecT s u m (Either Integer Double)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Either Integer Double
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-530"></span><span>
</span><span id="line-531"></span><span>    </span><span id="local-6989586621679061626"><span class="annot"><span class="annottext">decimalFloat :: ParsecT s u m (Either Integer Double)
</span><a href="#local-6989586621679061626"><span class="hs-identifier hs-var hs-var">decimalFloat</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061613"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061613"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span>
</span><span id="line-532"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Either Integer Double
-&gt; ParsecT s u m (Either Integer Double)
-&gt; ParsecT s u m (Either Integer Double)
forall s (m :: * -&gt; *) t a u.
Stream s m t =&gt;
a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#option"><span class="hs-identifier hs-var">option</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Either Integer Double
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061613"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-533"></span><span>                                 </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m (Either Integer Double)
forall {b} {a} {u} {a}.
(Read b, Show a) =&gt;
a -&gt; ParsecT s u m (Either a b)
</span><a href="#local-6989586621679061618"><span class="hs-identifier hs-var">fractFloat</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061613"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-534"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-535"></span><span>
</span><span id="line-536"></span><span>    </span><span id="local-6989586621679061618"><span class="annot"><span class="annottext">fractFloat :: a -&gt; ParsecT s u m (Either a b)
</span><a href="#local-6989586621679061618"><span class="hs-identifier hs-var hs-var">fractFloat</span></a></span></span><span> </span><span id="local-6989586621679061605"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061605"><span class="hs-identifier hs-var">n</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061604"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061604"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">a -&gt; ParsecT s u m b
forall {a} {a} {u}. (Read a, Show a) =&gt; a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061630"><span class="hs-identifier hs-var">fractExponent</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061605"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-537"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Either a b -&gt; ParsecT s u m (Either a b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b -&gt; Either a b
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061604"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-538"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-539"></span><span>
</span><span id="line-540"></span><span>    </span><span id="local-6989586621679061630"><span class="annot"><span class="annottext">fractExponent :: a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061630"><span class="hs-identifier hs-var hs-var">fractExponent</span></a></span></span><span> </span><span id="local-6989586621679061587"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061587"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061586"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061586"><span class="hs-identifier hs-var">fract</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061585"><span class="hs-identifier hs-var">fraction</span></a></span><span>
</span><span id="line-541"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061584"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061584"><span class="hs-identifier hs-var">expo</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t a u.
Stream s m t =&gt;
a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Combinator.html#option"><span class="hs-identifier hs-var">option</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061583"><span class="hs-identifier hs-var">exponent'</span></a></span><span>
</span><span id="line-542"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m a
forall {a} {s} {u} {m :: * -&gt; *}.
Read a =&gt;
String -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061582"><span class="hs-identifier hs-var">readDouble</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061587"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061586"><span class="hs-identifier hs-var">fract</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061584"><span class="hs-identifier hs-var">expo</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-543"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-544"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span>
</span><span id="line-545"></span><span>                      </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061580"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061580"><span class="hs-identifier hs-var">expo</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
forall {u}. ParsecT s u m String
</span><a href="#local-6989586621679061583"><span class="hs-identifier hs-var">exponent'</span></a></span><span>
</span><span id="line-546"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m a
forall {a} {s} {u} {m :: * -&gt; *}.
Read a =&gt;
String -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061582"><span class="hs-identifier hs-var">readDouble</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061587"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061580"><span class="hs-identifier hs-var">expo</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-547"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-548"></span><span>                      </span><span class="hs-keyword">where</span><span>
</span><span id="line-549"></span><span>                        </span><span id="local-6989586621679061582"><span class="annot"><span class="annottext">readDouble :: String -&gt; ParsecT s u m a
</span><a href="#local-6989586621679061582"><span class="hs-identifier hs-var hs-var">readDouble</span></a></span></span><span> </span><span id="local-6989586621679061576"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061576"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-550"></span><span>                          </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">ReadS a
forall a. Read a =&gt; ReadS a
</span><a href="../../base/src/Text.Read.html#reads"><span class="hs-identifier hs-var">reads</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061576"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-551"></span><span>                            </span><span class="hs-special">[</span><span class="hs-special">(</span><span id="local-6989586621679061574"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061574"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; ParsecT s u m a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679061574"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-552"></span><span>                            </span><span class="annot"><span class="annottext">[(a, String)]
</span><span class="hs-identifier">_</span></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a
forall s u (m :: * -&gt; *) a. ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#parserZero"><span class="hs-identifier hs-var">parserZero</span></a></span><span>
</span><span id="line-553"></span><span>
</span><span id="line-554"></span><span>    </span><span id="local-6989586621679061585"><span class="annot"><span class="annottext">fraction :: ParsecT s u m String
</span><a href="#local-6989586621679061585"><span class="hs-identifier hs-var hs-var">fraction</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'.'</span></span><span>
</span><span id="line-555"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061566"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061566"><span class="hs-identifier hs-var">digits</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#many1"><span class="hs-identifier hs-var">many1</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#digit"><span class="hs-identifier hs-var">digit</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;fraction&quot;</span></span><span>
</span><span id="line-556"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'.'</span></span><span> </span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061566"><span class="hs-identifier hs-var">digits</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-557"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-558"></span><span>                      </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;fraction&quot;</span></span><span>
</span><span id="line-559"></span><span>
</span><span id="line-560"></span><span>    </span><span id="local-6989586621679061583"><span class="annot"><span class="annottext">exponent' :: ParsecT s u m String
</span><a href="#local-6989586621679061583"><span class="hs-identifier hs-var hs-var">exponent'</span></a></span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;eE&quot;</span></span><span>
</span><span id="line-561"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061553"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061553"><span class="hs-identifier hs-var">sign'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; String) -&gt; ParsecT s u m Char -&gt; ParsecT s u m String
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var">fmap</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="hs-special">[</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;+-&quot;</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
-&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span>
</span><span id="line-562"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061552"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061552"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; String -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;exponent&quot;</span></span><span>
</span><span id="line-563"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'e'</span></span><span> </span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061553"><span class="hs-identifier hs-var">sign'</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061552"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-564"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-565"></span><span>                      </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;exponent&quot;</span></span><span>
</span><span id="line-566"></span><span>
</span><span id="line-567"></span><span>
</span><span id="line-568"></span><span>    </span><span class="hs-comment">-- integers and naturals</span><span>
</span><span id="line-569"></span><span>    </span><span id="local-6989586621679061638"><span class="annot"><span class="annottext">int :: ParsecT s u m Integer
</span><a href="#local-6989586621679061638"><span class="hs-identifier hs-var hs-var">int</span></a></span></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061548"><span class="annot"><span class="annottext">Integer -&gt; Integer
</span><a href="#local-6989586621679061548"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m (Integer -&gt; Integer)
forall {u}. ParsecT s u m (Integer -&gt; Integer)
</span><a href="#local-6989586621679061547"><span class="hs-identifier hs-var">sign</span></a></span><span>
</span><span id="line-570"></span><span>                        </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061546"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061546"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061637"><span class="hs-identifier hs-var">nat</span></a></span><span>
</span><span id="line-571"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer
</span><a href="#local-6989586621679061548"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061546"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-572"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-573"></span><span>
</span><span id="line-574"></span><span>    </span><span id="local-6989586621679061547"><span class="annot"><span class="annottext">sign :: ParsecT s u m (Integer -&gt; Integer)
</span><a href="#local-6989586621679061547"><span class="hs-identifier hs-var hs-var">sign</span></a></span></span><span>            </span><span class="hs-glyph">=</span><span>   </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'-'</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
-&gt; ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; ParsecT s u m (Integer -&gt; Integer)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#negate"><span class="hs-identifier hs-var">negate</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-575"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'+'</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
-&gt; ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; ParsecT s u m (Integer -&gt; Integer)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-576"></span><span>                    </span><span class="annot"><span class="annottext">ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
-&gt; ParsecT s u m (Integer -&gt; Integer)
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; ParsecT s u m (Integer -&gt; Integer)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span>
</span><span id="line-577"></span><span>
</span><span id="line-578"></span><span>    </span><span id="local-6989586621679061637"><span class="annot"><span class="annottext">nat :: ParsecT s u m Integer
</span><a href="#local-6989586621679061637"><span class="hs-identifier hs-var hs-var">nat</span></a></span></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061537"><span class="hs-identifier hs-var">zeroNumber</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span>
</span><span id="line-579"></span><span>
</span><span id="line-580"></span><span>    </span><span id="local-6989586621679061537"><span class="annot"><span class="annottext">zeroNumber :: ParsecT s u m Integer
</span><a href="#local-6989586621679061537"><span class="hs-identifier hs-var hs-var">zeroNumber</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'0'</span></span><span>
</span><span id="line-581"></span><span>                        </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061829"><span class="hs-identifier hs-var">hexadecimal</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061828"><span class="hs-identifier hs-var">octal</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var">decimal</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Integer
-&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>
</span><span id="line-582"></span><span>                        </span><span class="hs-special">}</span><span>
</span><span id="line-583"></span><span>                      </span><span class="annot"><span class="annottext">ParsecT s u m Integer -&gt; String -&gt; ParsecT s u m Integer
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span>
</span><span id="line-584"></span><span>
</span><span id="line-585"></span><span>    </span><span id="local-6989586621679061830"><span class="annot"><span class="annottext">decimal :: ParsecT s u m Integer
</span><a href="#local-6989586621679061830"><span class="hs-identifier hs-var hs-var">decimal</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
forall {s} {m :: * -&gt; *} {t} {u}.
Stream s m t =&gt;
Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var">number</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">10</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#digit"><span class="hs-identifier hs-var">digit</span></a></span><span>
</span><span id="line-586"></span><span>    </span><span id="local-6989586621679061829"><span class="annot"><span class="annottext">hexadecimal :: ParsecT s u m Integer
</span><a href="#local-6989586621679061829"><span class="hs-identifier hs-var hs-var">hexadecimal</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;xX&quot;</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
forall {s} {m :: * -&gt; *} {t} {u}.
Stream s m t =&gt;
Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var">number</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">16</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#hexDigit"><span class="hs-identifier hs-var">hexDigit</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-587"></span><span>    </span><span id="local-6989586621679061828"><span class="annot"><span class="annottext">octal :: ParsecT s u m Integer
</span><a href="#local-6989586621679061828"><span class="hs-identifier hs-var hs-var">octal</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;oO&quot;</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
forall {s} {m :: * -&gt; *} {t} {u}.
Stream s m t =&gt;
Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var">number</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
forall s (m :: * -&gt; *) u. Stream s m Char =&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#octDigit"><span class="hs-identifier hs-var">octDigit</span></a></span><span>  </span><span class="hs-special">}</span><span>
</span><span id="line-588"></span><span>
</span><span id="line-589"></span><span>    </span><span id="local-6989586621679061670"><span class="annot"><span class="annottext">number :: Integer -&gt; ParsecT s u m Char -&gt; ParsecT s u m Integer
</span><a href="#local-6989586621679061670"><span class="hs-identifier hs-var hs-var">number</span></a></span></span><span> </span><span id="local-6989586621679061518"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061518"><span class="hs-identifier hs-var">base</span></a></span></span><span> </span><span id="local-6989586621679061517"><span class="annot"><span class="annottext">ParsecT s u m Char
</span><a href="#local-6989586621679061517"><span class="hs-identifier hs-var">baseDigit</span></a></span></span><span>
</span><span id="line-590"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061516"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061516"><span class="hs-identifier hs-var">digits</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Combinator.html#many1"><span class="hs-identifier hs-var">many1</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char
</span><a href="#local-6989586621679061517"><span class="hs-identifier hs-var">baseDigit</span></a></span><span>
</span><span id="line-591"></span><span>            </span><span class="hs-special">;</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679061509"><span class="annot"><span class="annottext">n :: Integer
</span><a href="#local-6989586621679061509"><span class="hs-identifier hs-var hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Char -&gt; Integer) -&gt; Integer -&gt; String -&gt; Integer
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl"><span class="hs-identifier hs-var">foldl</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679061507"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061507"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679061506"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061506"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061518"><span class="hs-identifier hs-var">base</span></a></span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061507"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Integer
forall a. Integral a =&gt; a -&gt; Integer
</span><a href="../../base/src/GHC.Real.html#toInteger"><span class="hs-identifier hs-var">toInteger</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Int
</span><a href="../../base/src/Data.Char.html#digitToInt"><span class="hs-identifier hs-var">digitToInt</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061506"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061516"><span class="hs-identifier hs-var">digits</span></a></span><span>
</span><span id="line-592"></span><span>            </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Integer -&gt; ParsecT s u m Integer
</span><span class="hs-identifier hs-var">seq</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061509"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; ParsecT s u m Integer
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679061509"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-593"></span><span>            </span><span class="hs-special">}</span><span>
</span><span id="line-594"></span><span>
</span><span id="line-595"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-596"></span><span>    </span><span class="hs-comment">-- Operators &amp; reserved ops</span><span>
</span><span id="line-597"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-598"></span><span>    </span><span id="local-6989586621679061837"><span class="annot"><span class="annottext">reservedOp :: String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061837"><span class="hs-identifier hs-var hs-var">reservedOp</span></a></span></span><span> </span><span id="local-6989586621679061497"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061497"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-599"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m () -&gt; ParsecT s u m ())
-&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m () -&gt; ParsecT s u m ())
-&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-600"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061497"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-601"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t a u.
(Stream s m t, Show a) =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Combinator.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#opLetter"><span class="hs-identifier hs-var hs-var">opLetter</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061497"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-602"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-603"></span><span>
</span><span id="line-604"></span><span>    </span><span id="local-6989586621679061838"><span class="annot"><span class="annottext">operator :: ParsecT s u m String
</span><a href="#local-6989586621679061838"><span class="hs-identifier hs-var hs-var">operator</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-605"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m String -&gt; ParsecT s u m String)
-&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m String -&gt; ParsecT s u m String)
-&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-606"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061490"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061490"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
</span><a href="#local-6989586621679061489"><span class="hs-identifier hs-var">oper</span></a></span><span>
</span><span id="line-607"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Bool
</span><a href="#local-6989586621679061488"><span class="hs-identifier hs-var">isReservedOp</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061490"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-608"></span><span>             </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;reserved operator &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061490"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-609"></span><span>             </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061490"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-610"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-611"></span><span>
</span><span id="line-612"></span><span>    </span><span id="local-6989586621679061489"><span class="annot"><span class="annottext">oper :: ParsecT s u m String
</span><a href="#local-6989586621679061489"><span class="hs-identifier hs-var hs-var">oper</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-613"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061483"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061483"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#opStart"><span class="hs-identifier hs-var hs-var">opStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-614"></span><span>          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061482"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061482"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Prim.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#opLetter"><span class="hs-identifier hs-var hs-var">opLetter</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-615"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061483"><span class="hs-identifier hs-var">c</span></a></span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061482"><span class="hs-identifier hs-var">cs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-616"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-617"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;operator&quot;</span></span><span>
</span><span id="line-618"></span><span>
</span><span id="line-619"></span><span>    </span><span id="local-6989586621679061488"><span class="annot"><span class="annottext">isReservedOp :: String -&gt; Bool
</span><a href="#local-6989586621679061488"><span class="hs-identifier hs-var hs-var">isReservedOp</span></a></span></span><span> </span><span id="local-6989586621679061477"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061477"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-620"></span><span>        </span><span class="annot"><span class="annottext">[String] -&gt; String -&gt; Bool
forall {p}. Ord p =&gt; [p] -&gt; p -&gt; Bool
</span><a href="#local-6989586621679061476"><span class="hs-identifier hs-var">isReserved</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[String] -&gt; [String]
forall a. Ord a =&gt; [a] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#sort"><span class="hs-identifier hs-var">sort</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; [String]
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; [String]
</span><a href="Text.Parsec.Token.html#reservedOpNames"><span class="hs-identifier hs-var hs-var">reservedOpNames</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061477"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-621"></span><span>
</span><span id="line-622"></span><span>
</span><span id="line-623"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-624"></span><span>    </span><span class="hs-comment">-- Identifiers &amp; Reserved words</span><span>
</span><span id="line-625"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-626"></span><span>    </span><span id="local-6989586621679061839"><span class="annot"><span class="annottext">reserved :: String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061839"><span class="hs-identifier hs-var hs-var">reserved</span></a></span></span><span> </span><span id="local-6989586621679061470"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061470"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-627"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m () -&gt; ParsecT s u m ())
-&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m () -&gt; ParsecT s u m ())
-&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-628"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061469"><span class="hs-identifier hs-var">caseString</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061470"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-629"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t a u.
(Stream s m t, Show a) =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Combinator.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#identLetter"><span class="hs-identifier hs-var hs-var">identLetter</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061470"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-630"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-631"></span><span>
</span><span id="line-632"></span><span>    </span><span id="local-6989586621679061469"><span class="annot"><span class="annottext">caseString :: String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061469"><span class="hs-identifier hs-var hs-var">caseString</span></a></span></span><span> </span><span id="local-6989586621679061463"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061463"><span class="hs-identifier hs-var">name</span></a></span></span><span>
</span><span id="line-633"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; Bool
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#caseSensitive"><span class="hs-identifier hs-var hs-var">caseSensitive</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061463"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-634"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m ()
forall {s} {m :: * -&gt; *} {u}.
Stream s m Char =&gt;
String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061462"><span class="hs-identifier hs-var">walk</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061463"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061463"><span class="hs-identifier hs-var">name</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-635"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-636"></span><span>          </span><span id="local-6989586621679061462"><span class="annot"><span class="annottext">walk :: String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061462"><span class="hs-identifier hs-var hs-var">walk</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; ParsecT s u m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-637"></span><span>          </span><span class="annot"><a href="#local-6989586621679061462"><span class="hs-identifier hs-var">walk</span></a></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679061457"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061457"><span class="hs-identifier hs-var">c</span></a></span></span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span id="local-6989586621679061456"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061456"><span class="hs-identifier hs-var">cs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="#local-6989586621679061455"><span class="hs-identifier hs-var">caseChar</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061457"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; String -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061454"><span class="hs-identifier hs-var">msg</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679061462"><span class="hs-identifier hs-var">walk</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061456"><span class="hs-identifier hs-var">cs</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-638"></span><span>
</span><span id="line-639"></span><span>          </span><span id="local-6989586621679061455"><span class="annot"><span class="annottext">caseChar :: Char -&gt; ParsecT s u m Char
</span><a href="#local-6989586621679061455"><span class="hs-identifier hs-var hs-var">caseChar</span></a></span></span><span> </span><span id="local-6989586621679061449"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061449"><span class="hs-identifier hs-var">c</span></a></span></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isAlpha"><span class="hs-identifier hs-var">isAlpha</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061449"><span class="hs-identifier hs-var">c</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier hs-var">toLower</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061449"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m Char -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toUpper"><span class="hs-identifier hs-var">toUpper</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061449"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-640"></span><span>                      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
Char -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#char"><span class="hs-identifier hs-var">char</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061449"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-641"></span><span>
</span><span id="line-642"></span><span>          </span><span id="local-6989586621679061454"><span class="annot"><span class="annottext">msg :: String
</span><a href="#local-6989586621679061454"><span class="hs-identifier hs-var hs-var">msg</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061463"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-643"></span><span>
</span><span id="line-644"></span><span>
</span><span id="line-645"></span><span>    </span><span id="local-6989586621679061840"><span class="annot"><span class="annottext">identifier :: ParsecT s u m String
</span><a href="#local-6989586621679061840"><span class="hs-identifier hs-var hs-var">identifier</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-646"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m String -&gt; ParsecT s u m String)
-&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(ParsecT s u m String -&gt; ParsecT s u m String)
-&gt; ParsecT s u m String -&gt; ParsecT s u m String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-647"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061441"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061441"><span class="hs-identifier hs-var">name</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String
</span><a href="#local-6989586621679061440"><span class="hs-identifier hs-var">ident</span></a></span><span>
</span><span id="line-648"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Bool
</span><a href="#local-6989586621679061439"><span class="hs-identifier hs-var">isReservedName</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061441"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-649"></span><span>             </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;reserved word &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061441"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-650"></span><span>             </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061441"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-651"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-652"></span><span>
</span><span id="line-653"></span><span>
</span><span id="line-654"></span><span>    </span><span id="local-6989586621679061440"><span class="annot"><span class="annottext">ident :: ParsecT s u m String
</span><a href="#local-6989586621679061440"><span class="hs-identifier hs-var hs-var">ident</span></a></span></span><span>
</span><span id="line-655"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061435"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061435"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#identStart"><span class="hs-identifier hs-var hs-var">identStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>
</span><span id="line-656"></span><span>            </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679061434"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061434"><span class="hs-identifier hs-var">cs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m [a]
</span><a href="Text.Parsec.Prim.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; ParsecT s u m Char
forall s u (m :: * -&gt; *).
GenLanguageDef s u m -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Token.html#identLetter"><span class="hs-identifier hs-var hs-var">identLetter</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-657"></span><span>            </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679061435"><span class="hs-identifier hs-var">c</span></a></span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061434"><span class="hs-identifier hs-var">cs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-658"></span><span>            </span><span class="hs-special">}</span><span>
</span><span id="line-659"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;identifier&quot;</span></span><span>
</span><span id="line-660"></span><span>
</span><span id="line-661"></span><span>    </span><span id="local-6989586621679061439"><span class="annot"><span class="annottext">isReservedName :: String -&gt; Bool
</span><a href="#local-6989586621679061439"><span class="hs-identifier hs-var hs-var">isReservedName</span></a></span></span><span> </span><span id="local-6989586621679061431"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061431"><span class="hs-identifier hs-var">name</span></a></span></span><span>
</span><span id="line-662"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String -&gt; Bool
forall {p}. Ord p =&gt; [p] -&gt; p -&gt; Bool
</span><a href="#local-6989586621679061476"><span class="hs-identifier hs-var">isReserved</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679061430"><span class="hs-identifier hs-var">theReservedNames</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061429"><span class="hs-identifier hs-var">caseName</span></a></span><span>
</span><span id="line-663"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-664"></span><span>          </span><span id="local-6989586621679061429"><span class="annot"><span class="annottext">caseName :: String
</span><a href="#local-6989586621679061429"><span class="hs-identifier hs-var hs-var">caseName</span></a></span></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; Bool
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#caseSensitive"><span class="hs-identifier hs-var hs-var">caseSensitive</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061431"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-665"></span><span>                        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Char -&gt; Char) -&gt; String -&gt; String
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier hs-var">toLower</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061431"><span class="hs-identifier hs-var">name</span></a></span><span>
</span><span id="line-666"></span><span>
</span><span id="line-667"></span><span>
</span><span id="line-668"></span><span>    </span><span id="local-6989586621679061476"><span class="annot"><span class="annottext">isReserved :: [p] -&gt; p -&gt; Bool
</span><a href="#local-6989586621679061476"><span class="hs-identifier hs-var hs-var">isReserved</span></a></span></span><span> </span><span id="local-6989586621679061427"><span class="annot"><span class="annottext">[p]
</span><a href="#local-6989586621679061427"><span class="hs-identifier hs-var">names</span></a></span></span><span> </span><span id="local-6989586621679061426"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679061426"><span class="hs-identifier hs-var">name</span></a></span></span><span>
</span><span id="line-669"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[p] -&gt; Bool
</span><a href="#local-6989586621679061425"><span class="hs-identifier hs-var">scan</span></a></span><span> </span><span class="annot"><span class="annottext">[p]
</span><a href="#local-6989586621679061427"><span class="hs-identifier hs-var">names</span></a></span><span>
</span><span id="line-670"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-671"></span><span>          </span><span id="local-6989586621679061425"><span class="annot"><span class="annottext">scan :: [p] -&gt; Bool
</span><a href="#local-6989586621679061425"><span class="hs-identifier hs-var hs-var">scan</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-672"></span><span>          </span><span class="annot"><a href="#local-6989586621679061425"><span class="hs-identifier hs-var">scan</span></a></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679061423"><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679061423"><span class="hs-identifier hs-var">r</span></a></span></span><span class="annot"><span class="hs-glyph hs-type">:</span></span><span id="local-6989586621679061422"><span class="annot"><span class="annottext">[p]
</span><a href="#local-6989586621679061422"><span class="hs-identifier hs-var">rs</span></a></span></span><span class="hs-special">)</span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">p -&gt; p -&gt; Ordering
forall a. Ord a =&gt; a -&gt; a -&gt; Ordering
</span><span class="hs-identifier hs-var">compare</span></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679061423"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">p
</span><a href="#local-6989586621679061426"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-673"></span><span>                            </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">LT</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[p] -&gt; Bool
</span><a href="#local-6989586621679061425"><span class="hs-identifier hs-var">scan</span></a></span><span> </span><span class="annot"><span class="annottext">[p]
</span><a href="#local-6989586621679061422"><span class="hs-identifier hs-var">rs</span></a></span><span>
</span><span id="line-674"></span><span>                            </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">EQ</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">True</span></span><span>
</span><span id="line-675"></span><span>                            </span><span class="annot"><span class="annottext">Ordering
</span><span class="hs-identifier hs-var">GT</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier hs-var">False</span></span><span>
</span><span id="line-676"></span><span>
</span><span id="line-677"></span><span>    </span><span id="local-6989586621679061430"><span class="annot"><span class="annottext">theReservedNames :: [String]
</span><a href="#local-6989586621679061430"><span class="hs-identifier hs-var hs-var">theReservedNames</span></a></span></span><span>
</span><span id="line-678"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; Bool
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#caseSensitive"><span class="hs-identifier hs-var hs-var">caseSensitive</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[String] -&gt; [String]
forall a. Ord a =&gt; [a] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#sort"><span class="hs-identifier hs-var">sort</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679061417"><span class="hs-identifier hs-var">reserved</span></a></span><span>
</span><span id="line-679"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>                  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[String] -&gt; [String]
forall a. Ord a =&gt; [a] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#sort"><span class="hs-identifier hs-var">sort</span></a></span><span> </span><span class="annot"><span class="annottext">([String] -&gt; [String])
-&gt; ([String] -&gt; [String]) -&gt; [String] -&gt; [String]
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; String) -&gt; [String] -&gt; [String]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Char) -&gt; String -&gt; String
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char
</span><a href="../../base/src/GHC.Unicode.html#toLower"><span class="hs-identifier hs-var">toLower</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([String] -&gt; [String]) -&gt; [String] -&gt; [String]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621679061417"><span class="hs-identifier hs-var">reserved</span></a></span><span>
</span><span id="line-680"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-681"></span><span>          </span><span id="local-6989586621679061417"><span class="annot"><span class="annottext">reserved :: [String]
</span><a href="#local-6989586621679061417"><span class="hs-identifier hs-var hs-var">reserved</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; [String]
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; [String]
</span><a href="Text.Parsec.Token.html#reservedNames"><span class="hs-identifier hs-var hs-var">reservedNames</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>
</span><span id="line-682"></span><span>
</span><span id="line-683"></span><span>
</span><span id="line-684"></span><span>
</span><span id="line-685"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-686"></span><span>    </span><span class="hs-comment">-- White space &amp; symbols</span><span>
</span><span id="line-687"></span><span>    </span><span class="hs-comment">-----------------------------------------------------------</span><span>
</span><span id="line-688"></span><span>    </span><span id="local-6989586621679061827"><span class="annot"><span class="annottext">symbol :: String -&gt; ParsecT s u m String
</span><a href="#local-6989586621679061827"><span class="hs-identifier hs-var hs-var">symbol</span></a></span></span><span> </span><span id="local-6989586621679061414"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061414"><span class="hs-identifier hs-var">name</span></a></span></span><span>
</span><span id="line-689"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall {u} {b}. ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var">lexeme</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061414"><span class="hs-identifier hs-var">name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-690"></span><span>
</span><span id="line-691"></span><span>    </span><span id="local-6989586621679061826"><span class="annot"><span class="annottext">lexeme :: ParsecT s u m b -&gt; ParsecT s u m b
</span><a href="#local-6989586621679061826"><span class="hs-identifier hs-var hs-var">lexeme</span></a></span></span><span> </span><span id="local-6989586621679061410"><span class="annot"><span class="annottext">ParsecT s u m b
</span><a href="#local-6989586621679061410"><span class="hs-identifier hs-var">p</span></a></span></span><span>
</span><span id="line-692"></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span id="local-6989586621679061409"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061409"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m b
</span><a href="#local-6989586621679061410"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061825"><span class="hs-identifier hs-var">whiteSpace</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">b -&gt; ParsecT s u m b
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679061409"><span class="hs-identifier hs-var">x</span></a></span><span>  </span><span class="hs-special">}</span><span>
</span><span id="line-693"></span><span>
</span><span id="line-694"></span><span>
</span><span id="line-695"></span><span>    </span><span class="hs-comment">--whiteSpace</span><span>
</span><span id="line-696"></span><span>    </span><span id="local-6989586621679061825"><span class="annot"><span class="annottext">whiteSpace :: ParsecT s u m ()
</span><a href="#local-6989586621679061825"><span class="hs-identifier hs-var hs-var">whiteSpace</span></a></span></span><span>
</span><span id="line-697"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679061408"><span class="hs-identifier hs-var">noLine</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679061407"><span class="hs-identifier hs-var">noMulti</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061405"><span class="hs-identifier hs-var">simpleSpace</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-698"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679061408"><span class="hs-identifier hs-var">noLine</span></a></span><span>             </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061405"><span class="hs-identifier hs-var">simpleSpace</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061404"><span class="hs-identifier hs-var">multiLineComment</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-699"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679061407"><span class="hs-identifier hs-var">noMulti</span></a></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061405"><span class="hs-identifier hs-var">simpleSpace</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061403"><span class="hs-identifier hs-var">oneLineComment</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-700"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061405"><span class="hs-identifier hs-var">simpleSpace</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061403"><span class="hs-identifier hs-var">oneLineComment</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061404"><span class="hs-identifier hs-var">multiLineComment</span></a></span><span> </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-701"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-702"></span><span>          </span><span id="local-6989586621679061408"><span class="annot"><span class="annottext">noLine :: Bool
</span><a href="#local-6989586621679061408"><span class="hs-identifier hs-var hs-var">noLine</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#null"><span class="hs-identifier hs-var">null</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentLine"><span class="hs-identifier hs-var hs-var">commentLine</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-703"></span><span>          </span><span id="local-6989586621679061407"><span class="annot"><span class="annottext">noMulti :: Bool
</span><a href="#local-6989586621679061407"><span class="hs-identifier hs-var hs-var">noMulti</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Bool
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Bool
</span><a href="../../base/src/Data.Foldable.html#null"><span class="hs-identifier hs-var">null</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentStart"><span class="hs-identifier hs-var hs-var">commentStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-704"></span><span>
</span><span id="line-705"></span><span>
</span><span id="line-706"></span><span>    </span><span id="local-6989586621679061405"><span class="annot"><span class="annottext">simpleSpace :: ParsecT s u m ()
</span><a href="#local-6989586621679061405"><span class="hs-identifier hs-var hs-var">simpleSpace</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-707"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Combinator.html#skipMany1"><span class="hs-identifier hs-var">skipMany1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="../../base/src/GHC.Unicode.html#isSpace"><span class="hs-identifier hs-var">isSpace</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-708"></span><span>
</span><span id="line-709"></span><span>    </span><span id="local-6989586621679061403"><span class="annot"><span class="annottext">oneLineComment :: ParsecT s u m ()
</span><a href="#local-6989586621679061403"><span class="hs-identifier hs-var hs-var">oneLineComment</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-710"></span><span>        </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentLine"><span class="hs-identifier hs-var hs-var">commentLine</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-711"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
(Char -&gt; Bool) -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#satisfy"><span class="hs-identifier hs-var">satisfy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\n'</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-712"></span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">() -&gt; ParsecT s u m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-713"></span><span>          </span><span class="hs-special">}</span><span>
</span><span id="line-714"></span><span>
</span><span id="line-715"></span><span>    </span><span id="local-6989586621679061404"><span class="annot"><span class="annottext">multiLineComment :: ParsecT s u m ()
</span><a href="#local-6989586621679061404"><span class="hs-identifier hs-var hs-var">multiLineComment</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-716"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentStart"><span class="hs-identifier hs-var hs-var">commentStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-717"></span><span>           </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061379"><span class="hs-identifier hs-var">inComment</span></a></span><span>
</span><span id="line-718"></span><span>           </span><span class="hs-special">}</span><span>
</span><span id="line-719"></span><span>
</span><span id="line-720"></span><span>    </span><span id="local-6989586621679061379"><span class="annot"><span class="annottext">inComment :: ParsecT s u m ()
</span><a href="#local-6989586621679061379"><span class="hs-identifier hs-var hs-var">inComment</span></a></span></span><span>
</span><span id="line-721"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; Bool
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; Bool
</span><a href="Text.Parsec.Token.html#nestedComments"><span class="hs-identifier hs-var hs-var">nestedComments</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061378"><span class="hs-identifier hs-var">inCommentMulti</span></a></span><span>
</span><span id="line-722"></span><span>        </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>                </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall {u}. ParsecT s u m ()
</span><a href="#local-6989586621679061377"><span class="hs-identifier hs-var">inCommentSingle</span></a></span><span>
</span><span id="line-723"></span><span>
</span><span id="line-724"></span><span>    </span><span id="local-6989586621679061378"><span class="annot"><span class="annottext">inCommentMulti :: ParsecT s u m ()
</span><a href="#local-6989586621679061378"><span class="hs-identifier hs-var hs-var">inCommentMulti</span></a></span></span><span>
</span><span id="line-725"></span><span>        </span><span class="hs-glyph">=</span><span>   </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentEnd"><span class="hs-identifier hs-var hs-var">commentEnd</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">() -&gt; ParsecT s u m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-726"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061404"><span class="hs-identifier hs-var">multiLineComment</span></a></span><span>                     </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061378"><span class="hs-identifier hs-var">inCommentMulti</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-727"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Combinator.html#skipMany1"><span class="hs-identifier hs-var">skipMany1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#noneOf"><span class="hs-identifier hs-var">noneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061375"><span class="hs-identifier hs-var">startEnd</span></a></span><span class="hs-special">)</span><span>          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061378"><span class="hs-identifier hs-var">inCommentMulti</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-728"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061375"><span class="hs-identifier hs-var">startEnd</span></a></span><span>                  </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061378"><span class="hs-identifier hs-var">inCommentMulti</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-729"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of comment&quot;</span></span><span>
</span><span id="line-730"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-731"></span><span>          </span><span id="local-6989586621679061375"><span class="annot"><span class="annottext">startEnd :: String
</span><a href="#local-6989586621679061375"><span class="hs-identifier hs-var hs-var">startEnd</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Eq a =&gt; [a] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#nub"><span class="hs-identifier hs-var">nub</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentEnd"><span class="hs-identifier hs-var hs-var">commentEnd</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentStart"><span class="hs-identifier hs-var hs-var">commentStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-732"></span><span>
</span><span id="line-733"></span><span>    </span><span id="local-6989586621679061377"><span class="annot"><span class="annottext">inCommentSingle :: ParsecT s u m ()
</span><a href="#local-6989586621679061377"><span class="hs-identifier hs-var hs-var">inCommentSingle</span></a></span></span><span>
</span><span id="line-734"></span><span>        </span><span class="hs-glyph">=</span><span>   </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m String -&gt; ParsecT s u m String
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m String
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m String
</span><a href="Text.Parsec.Char.html#string"><span class="hs-identifier hs-var">string</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentEnd"><span class="hs-identifier hs-var hs-var">commentEnd</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">() -&gt; ParsecT s u m ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-735"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m Char -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="Text.Parsec.Combinator.html#skipMany1"><span class="hs-identifier hs-var">skipMany1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#noneOf"><span class="hs-identifier hs-var">noneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061365"><span class="hs-identifier hs-var">startEnd</span></a></span><span class="hs-special">)</span><span>         </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061377"><span class="hs-identifier hs-var">inCommentSingle</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-736"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; ParsecT s u m () -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-keyword">do</span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m Char
forall s (m :: * -&gt; *) u.
Stream s m Char =&gt;
String -&gt; ParsecT s u m Char
</span><a href="Text.Parsec.Char.html#oneOf"><span class="hs-identifier hs-var">oneOf</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679061365"><span class="hs-identifier hs-var">startEnd</span></a></span><span>                 </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
</span><a href="#local-6989586621679061377"><span class="hs-identifier hs-var">inCommentSingle</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-737"></span><span>        </span><span class="annot"><span class="annottext">ParsecT s u m () -&gt; String -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;end of comment&quot;</span></span><span>
</span><span id="line-738"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-739"></span><span>          </span><span id="local-6989586621679061365"><span class="annot"><span class="annottext">startEnd :: String
</span><a href="#local-6989586621679061365"><span class="hs-identifier hs-var hs-var">startEnd</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String
forall a. Eq a =&gt; [a] -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#nub"><span class="hs-identifier hs-var">nub</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentEnd"><span class="hs-identifier hs-var hs-var">commentEnd</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m -&gt; String
forall s u (m :: * -&gt; *). GenLanguageDef s u m -&gt; String
</span><a href="Text.Parsec.Token.html#commentStart"><span class="hs-identifier hs-var hs-var">commentStart</span></a></span><span> </span><span class="annot"><span class="annottext">GenLanguageDef s u m
</span><a href="#local-6989586621679061841"><span class="hs-identifier hs-var">languageDef</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-740"></span></pre></body></html>